ghc-lib-parser 0.20200205 → 0.20200301

raw patch · 188 files changed

+33321/−33085 lines, 188 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- ApiAnnotation: AnnEofPos :: AnnKeywordId

- ApiAnnotation: type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])

- BkpSyn: DeclD :: HscSource -> Located ModuleName -> Maybe (Located HsModule) -> HsUnitDecl n

- BkpSyn: HsComponentId :: PackageName -> ComponentId -> HsComponentId

- BkpSyn: HsModuleId :: LHsUnitId n -> Located ModuleName -> HsModuleId n

- BkpSyn: HsModuleVar :: Located ModuleName -> HsModuleId n

- BkpSyn: HsUnit :: Located n -> [LHsUnitDecl n] -> HsUnit n

- BkpSyn: HsUnitId :: Located n -> [LHsModuleSubst n] -> HsUnitId n

- BkpSyn: IncludeD :: IncludeDecl n -> HsUnitDecl n

- BkpSyn: IncludeDecl :: LHsUnitId n -> Maybe [LRenaming] -> Bool -> IncludeDecl n

- BkpSyn: Renaming :: Located ModuleName -> Maybe (Located ModuleName) -> Renaming

- BkpSyn: [hsComponentId] :: HsComponentId -> ComponentId

- BkpSyn: [hsPackageName] :: HsComponentId -> PackageName

- BkpSyn: [hsunitBody] :: HsUnit n -> [LHsUnitDecl n]

- BkpSyn: [hsunitName] :: HsUnit n -> Located n

- BkpSyn: [idModRenaming] :: IncludeDecl n -> Maybe [LRenaming]

- BkpSyn: [idSignatureInclude] :: IncludeDecl n -> Bool

- BkpSyn: [idUnitId] :: IncludeDecl n -> LHsUnitId n

- BkpSyn: [renameFrom] :: Renaming -> Located ModuleName

- BkpSyn: [renameTo] :: Renaming -> Maybe (Located ModuleName)

- BkpSyn: data HsComponentId

- BkpSyn: data HsModuleId n

- BkpSyn: data HsUnit n

- BkpSyn: data HsUnitDecl n

- BkpSyn: data HsUnitId n

- BkpSyn: data IncludeDecl n

- BkpSyn: data Renaming

- BkpSyn: instance Outputable.Outputable BkpSyn.HsComponentId

- BkpSyn: type HsModuleSubst n = (Located ModuleName, LHsModuleId n)

- BkpSyn: type LHsModuleId n = Located (HsModuleId n)

- BkpSyn: type LHsModuleSubst n = Located (HsModuleSubst n)

- BkpSyn: type LHsUnit n = Located (HsUnit n)

- BkpSyn: type LHsUnitDecl n = Located (HsUnitDecl n)

- BkpSyn: type LHsUnitId n = Located (HsUnitId n)

- BkpSyn: type LRenaming = Located Renaming

- ByteCodeTypes: BCONPtrItbl :: !Name -> BCONPtr

- ByteCodeTypes: BCONPtrLbl :: !FastString -> BCONPtr

- ByteCodeTypes: BCONPtrStr :: !ByteString -> BCONPtr

- ByteCodeTypes: BCONPtrWord :: {-# UNPACK #-} !Word -> BCONPtr

- ByteCodeTypes: BCOPtrBCO :: !UnlinkedBCO -> BCOPtr

- ByteCodeTypes: BCOPtrBreakArray :: BCOPtr

- ByteCodeTypes: BCOPtrName :: !Name -> BCOPtr

- ByteCodeTypes: BCOPtrPrimOp :: !PrimOp -> BCOPtr

- ByteCodeTypes: CgBreakInfo :: [Maybe (Id, Word16)] -> Type -> CgBreakInfo

- ByteCodeTypes: CompiledByteCode :: [UnlinkedBCO] -> ItblEnv -> [FFIInfo] -> [RemotePtr ()] -> Maybe ModBreaks -> CompiledByteCode

- ByteCodeTypes: FFIInfo :: RemotePtr C_ffi_cif -> FFIInfo

- ByteCodeTypes: ItblPtr :: RemotePtr StgInfoTable -> ItblPtr

- ByteCodeTypes: ModBreaks :: ForeignRef BreakArray -> !Array BreakIndex SrcSpan -> !Array BreakIndex [OccName] -> !Array BreakIndex [String] -> !Array BreakIndex (RemotePtr CostCentre) -> IntMap CgBreakInfo -> ModBreaks

- ByteCodeTypes: UnlinkedBCO :: !Name -> {-# UNPACK #-} !Int -> !UArray Int Word16 -> !UArray Int Word64 -> !SizedSeq BCONPtr -> !SizedSeq BCOPtr -> UnlinkedBCO

- ByteCodeTypes: [bc_bcos] :: CompiledByteCode -> [UnlinkedBCO]

- ByteCodeTypes: [bc_breaks] :: CompiledByteCode -> Maybe ModBreaks

- ByteCodeTypes: [bc_ffis] :: CompiledByteCode -> [FFIInfo]

- ByteCodeTypes: [bc_itbls] :: CompiledByteCode -> ItblEnv

- ByteCodeTypes: [bc_strs] :: CompiledByteCode -> [RemotePtr ()]

- ByteCodeTypes: [cgb_resty] :: CgBreakInfo -> Type

- ByteCodeTypes: [cgb_vars] :: CgBreakInfo -> [Maybe (Id, Word16)]

- ByteCodeTypes: [modBreaks_breakInfo] :: ModBreaks -> IntMap CgBreakInfo

- ByteCodeTypes: [modBreaks_ccs] :: ModBreaks -> !Array BreakIndex (RemotePtr CostCentre)

- ByteCodeTypes: [modBreaks_decls] :: ModBreaks -> !Array BreakIndex [String]

- ByteCodeTypes: [modBreaks_flags] :: ModBreaks -> ForeignRef BreakArray

- ByteCodeTypes: [modBreaks_locs] :: ModBreaks -> !Array BreakIndex SrcSpan

- ByteCodeTypes: [modBreaks_vars] :: ModBreaks -> !Array BreakIndex [OccName]

- ByteCodeTypes: [unlinkedBCOArity] :: UnlinkedBCO -> {-# UNPACK #-} !Int

- ByteCodeTypes: [unlinkedBCOBitmap] :: UnlinkedBCO -> !UArray Int Word64

- ByteCodeTypes: [unlinkedBCOInstrs] :: UnlinkedBCO -> !UArray Int Word16

- ByteCodeTypes: [unlinkedBCOLits] :: UnlinkedBCO -> !SizedSeq BCONPtr

- ByteCodeTypes: [unlinkedBCOName] :: UnlinkedBCO -> !Name

- ByteCodeTypes: [unlinkedBCOPtrs] :: UnlinkedBCO -> !SizedSeq BCOPtr

- ByteCodeTypes: data BCONPtr

- ByteCodeTypes: data BCOPtr

- ByteCodeTypes: data CCostCentre

- ByteCodeTypes: data CgBreakInfo

- ByteCodeTypes: data CompiledByteCode

- ByteCodeTypes: data ModBreaks

- ByteCodeTypes: data UnlinkedBCO

- ByteCodeTypes: emptyModBreaks :: ModBreaks

- ByteCodeTypes: instance Control.DeepSeq.NFData ByteCodeTypes.BCONPtr

- ByteCodeTypes: instance Control.DeepSeq.NFData ByteCodeTypes.BCOPtr

- ByteCodeTypes: instance Control.DeepSeq.NFData ByteCodeTypes.FFIInfo

- ByteCodeTypes: instance Control.DeepSeq.NFData ByteCodeTypes.ItblPtr

- ByteCodeTypes: instance Control.DeepSeq.NFData ByteCodeTypes.UnlinkedBCO

- ByteCodeTypes: instance GHC.Show.Show ByteCodeTypes.FFIInfo

- ByteCodeTypes: instance GHC.Show.Show ByteCodeTypes.ItblPtr

- ByteCodeTypes: instance Outputable.Outputable ByteCodeTypes.CgBreakInfo

- ByteCodeTypes: instance Outputable.Outputable ByteCodeTypes.CompiledByteCode

- ByteCodeTypes: instance Outputable.Outputable ByteCodeTypes.UnlinkedBCO

- ByteCodeTypes: newtype FFIInfo

- ByteCodeTypes: newtype ItblPtr

- ByteCodeTypes: seqCompiledByteCode :: CompiledByteCode -> ()

- ByteCodeTypes: type BreakIndex = Int

- ByteCodeTypes: type ItblEnv = NameEnv (Name, ItblPtr)

- CmdLineParser: AllModes :: GhcFlagMode

- CmdLineParser: AnySuffix :: (String -> EwM m ()) -> OptKind m

- CmdLineParser: CmdLineP :: (s -> (a, s)) -> CmdLineP s a

- CmdLineParser: Err :: Located String -> Err

- CmdLineParser: Flag :: String -> OptKind m -> GhcFlagMode -> Flag m

- CmdLineParser: FloatSuffix :: (Float -> EwM m ()) -> OptKind m

- CmdLineParser: HasArg :: (String -> EwM m ()) -> OptKind m

- CmdLineParser: HiddenFlag :: GhcFlagMode

- CmdLineParser: IntSuffix :: (Int -> EwM m ()) -> OptKind m

- CmdLineParser: NoArg :: EwM m () -> OptKind m

- CmdLineParser: NoReason :: WarnReason

- CmdLineParser: OnlyGhc :: GhcFlagMode

- CmdLineParser: OnlyGhci :: GhcFlagMode

- CmdLineParser: OptIntSuffix :: (Maybe Int -> EwM m ()) -> OptKind m

- CmdLineParser: OptPrefix :: (String -> EwM m ()) -> OptKind m

- CmdLineParser: PassFlag :: (String -> EwM m ()) -> OptKind m

- CmdLineParser: Prefix :: (String -> EwM m ()) -> OptKind m

- CmdLineParser: ReasonDeprecatedFlag :: WarnReason

- CmdLineParser: ReasonUnrecognisedFlag :: WarnReason

- CmdLineParser: SepArg :: (String -> EwM m ()) -> OptKind m

- CmdLineParser: Warn :: WarnReason -> Located String -> Warn

- CmdLineParser: [errMsg] :: Err -> Located String

- CmdLineParser: [flagGhcMode] :: Flag m -> GhcFlagMode

- CmdLineParser: [flagName] :: Flag m -> String

- CmdLineParser: [flagOptKind] :: Flag m -> OptKind m

- CmdLineParser: [runCmdLine] :: CmdLineP s a -> s -> (a, s)

- CmdLineParser: [warnMsg] :: Warn -> Located String

- CmdLineParser: [warnReason] :: Warn -> WarnReason

- CmdLineParser: addErr :: Monad m => String -> EwM m ()

- CmdLineParser: addFlagWarn :: Monad m => WarnReason -> String -> EwM m ()

- CmdLineParser: addWarn :: Monad m => String -> EwM m ()

- CmdLineParser: data EwM m a

- CmdLineParser: data Flag m

- CmdLineParser: data GhcFlagMode

- CmdLineParser: data OptKind m

- CmdLineParser: data Warn

- CmdLineParser: data WarnReason

- CmdLineParser: defFlag :: String -> OptKind m -> Flag m

- CmdLineParser: defGhcFlag :: String -> OptKind m -> Flag m

- CmdLineParser: defGhciFlag :: String -> OptKind m -> Flag m

- CmdLineParser: defHiddenFlag :: String -> OptKind m -> Flag m

- CmdLineParser: deprecate :: Monad m => String -> EwM m ()

- CmdLineParser: errorsToGhcException :: [(String, String)] -> GhcException

- CmdLineParser: getArg :: Monad m => EwM m String

- CmdLineParser: getCmdLineState :: CmdLineP s s

- CmdLineParser: getCurLoc :: Monad m => EwM m SrcSpan

- CmdLineParser: instance GHC.Base.Applicative (CmdLineParser.CmdLineP s)

- CmdLineParser: instance GHC.Base.Functor (CmdLineParser.CmdLineP s)

- CmdLineParser: instance GHC.Base.Monad (CmdLineParser.CmdLineP s)

- CmdLineParser: instance GHC.Base.Monad m => GHC.Base.Applicative (CmdLineParser.EwM m)

- CmdLineParser: instance GHC.Base.Monad m => GHC.Base.Functor (CmdLineParser.EwM m)

- CmdLineParser: instance GHC.Base.Monad m => GHC.Base.Monad (CmdLineParser.EwM m)

- 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: liftEwM :: Monad m => m a -> EwM m a

- CmdLineParser: newtype CmdLineP s a

- CmdLineParser: newtype Err

- CmdLineParser: processArgs :: Monad m => [Flag m] -> [Located String] -> m ([Located String], [Err], [Warn])

- CmdLineParser: putCmdLineState :: s -> CmdLineP s ()

- CmdLineParser: runEwM :: EwM m a -> m (Errs, Warns, a)

- Coercion: mkUnsafeCo :: Role -> Type -> Type -> Coercion

- CoreArity: etaExpand :: Arity -> CoreExpr -> CoreExpr

- CoreArity: etaExpandToJoinPoint :: JoinArity -> CoreExpr -> ([CoreBndr], CoreExpr)

- CoreArity: etaExpandToJoinPointRule :: JoinArity -> CoreRule -> CoreRule

- CoreArity: exprArity :: CoreExpr -> Arity

- CoreArity: exprBotStrictness_maybe :: CoreExpr -> Maybe (Arity, StrictSig)

- CoreArity: exprEtaExpandArity :: DynFlags -> CoreExpr -> Arity

- CoreArity: findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> (Arity, Bool)

- CoreArity: instance Outputable.Outputable CoreArity.ArityType

- CoreArity: instance Outputable.Outputable CoreArity.EtaInfo

- CoreArity: joinRhsArity :: CoreExpr -> JoinArity

- CoreArity: manifestArity :: CoreExpr -> Arity

- CoreArity: typeArity :: Type -> [OneShotInfo]

- CoreFVs: bindFreeVars :: CoreBind -> VarSet

- CoreFVs: bndrRuleAndUnfoldingVarsDSet :: Id -> DVarSet

- CoreFVs: dIdFreeVars :: Id -> DVarSet

- CoreFVs: exprFreeIds :: CoreExpr -> IdSet

- CoreFVs: exprFreeIdsDSet :: CoreExpr -> DIdSet

- CoreFVs: exprFreeIdsList :: CoreExpr -> [Id]

- CoreFVs: exprFreeVars :: CoreExpr -> VarSet

- CoreFVs: exprFreeVarsDSet :: CoreExpr -> DVarSet

- CoreFVs: exprFreeVarsList :: CoreExpr -> [Var]

- CoreFVs: exprSomeFreeVars :: InterestingVarFun -> CoreExpr -> VarSet

- CoreFVs: exprSomeFreeVarsList :: InterestingVarFun -> CoreExpr -> [Var]

- CoreFVs: expr_fvs :: CoreExpr -> FV

- CoreFVs: exprsFreeIdsDSet :: [CoreExpr] -> DIdSet

- CoreFVs: exprsFreeIdsList :: [CoreExpr] -> [Id]

- CoreFVs: exprsFreeVars :: [CoreExpr] -> VarSet

- CoreFVs: exprsFreeVarsList :: [CoreExpr] -> [Var]

- CoreFVs: exprsOrphNames :: [CoreExpr] -> NameSet

- CoreFVs: exprsSomeFreeVars :: InterestingVarFun -> [CoreExpr] -> VarSet

- CoreFVs: exprsSomeFreeVarsList :: InterestingVarFun -> [CoreExpr] -> [Var]

- CoreFVs: freeVars :: CoreExpr -> CoreExprWithFVs

- CoreFVs: freeVarsBind :: CoreBind -> DVarSet -> (CoreBindWithFVs, DVarSet)

- CoreFVs: freeVarsOf :: CoreExprWithFVs -> DIdSet

- CoreFVs: freeVarsOfAnn :: FVAnn -> DIdSet

- CoreFVs: idFVs :: Id -> FV

- CoreFVs: idFreeVars :: Id -> VarSet

- CoreFVs: idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet

- CoreFVs: idRuleVars :: Id -> VarSet

- CoreFVs: idUnfoldingVars :: Id -> VarSet

- CoreFVs: orphNamesOfAxiom :: CoAxiom br -> NameSet

- CoreFVs: orphNamesOfCo :: Coercion -> NameSet

- CoreFVs: orphNamesOfCoCon :: CoAxiom br -> NameSet

- CoreFVs: orphNamesOfFamInst :: FamInst -> NameSet

- CoreFVs: orphNamesOfType :: Type -> NameSet

- CoreFVs: orphNamesOfTypes :: [Type] -> NameSet

- CoreFVs: ruleFreeVars :: CoreRule -> VarSet

- CoreFVs: ruleLhsFreeIds :: CoreRule -> VarSet

- CoreFVs: ruleLhsFreeIdsList :: CoreRule -> [Var]

- CoreFVs: ruleRhsFreeVars :: CoreRule -> VarSet

- CoreFVs: rulesFreeVars :: [CoreRule] -> VarSet

- CoreFVs: rulesFreeVarsDSet :: [CoreRule] -> DVarSet

- CoreFVs: stableUnfoldingVars :: Unfolding -> Maybe VarSet

- CoreFVs: type CoreAltWithFVs = AnnAlt Id FVAnn

- CoreFVs: type CoreBindWithFVs = AnnBind Id FVAnn

- CoreFVs: type CoreExprWithFVs = AnnExpr Id FVAnn

- CoreFVs: type CoreExprWithFVs' = AnnExpr' Id FVAnn

- CoreFVs: type FVAnn = DVarSet

- CoreFVs: type InterestingVarFun = Var -> Bool

- CoreFVs: varTypeTyCoFVs :: Var -> FV

- CoreFVs: varTypeTyCoVars :: Var -> TyCoVarSet

- CoreMap: (>.>) :: (a -> b) -> (b -> c) -> a -> c

- CoreMap: (|>) :: a -> (a -> b) -> b

- CoreMap: (|>>) :: TrieMap m2 => (XT (m2 a) -> m1 (m2 a) -> m1 (m2 a)) -> (m2 a -> m2 a) -> m1 (m2 a) -> m1 (m2 a)

- CoreMap: alterTM :: forall b. TrieMap m => Key m -> XT b -> m b -> m b

- CoreMap: class TrieMap m where {

- CoreMap: data CmEnv

- CoreMap: data CoreMap a

- CoreMap: data GenMap m a

- CoreMap: data ListMap m a

- CoreMap: data LooseTypeMap a

- CoreMap: data MaybeMap m a

- CoreMap: data TypeMap a

- CoreMap: deleteTM :: TrieMap m => Key m -> m a -> m a

- CoreMap: emptyCoreMap :: CoreMap a

- CoreMap: emptyTM :: TrieMap m => m a

- CoreMap: emptyTypeMap :: TypeMap a

- CoreMap: extendCoreMap :: CoreMap a -> CoreExpr -> a -> CoreMap a

- CoreMap: extendTypeMap :: TypeMap a -> Type -> a -> TypeMap a

- CoreMap: extendTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> a -> TypeMap a

- CoreMap: foldCoreMap :: (a -> b -> b) -> b -> CoreMap a -> b

- CoreMap: foldTM :: TrieMap m => (a -> b -> b) -> m a -> b -> b

- CoreMap: foldTypeMap :: (a -> b -> b) -> b -> TypeMap a -> b

- CoreMap: infixr 1 |>>

- CoreMap: insertTM :: TrieMap m => Key m -> a -> m a -> m a

- CoreMap: instance GHC.Classes.Eq (CoreMap.DeBruijn CoreSyn.CoreAlt)

- CoreMap: instance GHC.Classes.Eq (CoreMap.DeBruijn CoreSyn.CoreExpr)

- CoreMap: instance GHC.Classes.Eq (CoreMap.DeBruijn TyCoRep.Coercion)

- CoreMap: instance GHC.Classes.Eq (CoreMap.DeBruijn TyCoRep.Type)

- CoreMap: instance GHC.Classes.Eq (CoreMap.DeBruijn a) => GHC.Classes.Eq (CoreMap.DeBruijn [a])

- CoreMap: instance Outputable.Outputable a => Outputable.Outputable (CoreMap.CoreMap a)

- CoreMap: instance Outputable.Outputable a => Outputable.Outputable (CoreMap.TypeMapG a)

- CoreMap: instance TrieMap.TrieMap CoreMap.AltMap

- CoreMap: instance TrieMap.TrieMap CoreMap.CoercionMap

- CoreMap: instance TrieMap.TrieMap CoreMap.CoercionMapX

- CoreMap: instance TrieMap.TrieMap CoreMap.CoreMap

- CoreMap: instance TrieMap.TrieMap CoreMap.CoreMapX

- CoreMap: instance TrieMap.TrieMap CoreMap.LooseTypeMap

- CoreMap: instance TrieMap.TrieMap CoreMap.TyLitMap

- CoreMap: instance TrieMap.TrieMap CoreMap.TypeMap

- CoreMap: instance TrieMap.TrieMap CoreMap.TypeMapX

- CoreMap: instance TrieMap.TrieMap CoreMap.VarMap

- CoreMap: lkDFreeVar :: Var -> DVarEnv a -> Maybe a

- CoreMap: lkDNamed :: NamedThing n => n -> DNameEnv a -> Maybe a

- CoreMap: lookupCME :: CmEnv -> Var -> Maybe BoundVar

- CoreMap: lookupCoreMap :: CoreMap a -> CoreExpr -> Maybe a

- CoreMap: lookupTM :: forall b. TrieMap m => Key m -> m b -> Maybe b

- CoreMap: lookupTypeMap :: TypeMap a -> Type -> Maybe a

- CoreMap: lookupTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> Maybe a

- CoreMap: mapTM :: TrieMap m => (a -> b) -> m a -> m b

- CoreMap: mkDeBruijnContext :: [Var] -> CmEnv

- CoreMap: type LiteralMap a = Map Literal a

- CoreMap: type family Key m :: *;

- CoreMap: xtDFreeVar :: Var -> XT a -> DVarEnv a -> DVarEnv a

- CoreMap: xtDNamed :: NamedThing n => n -> XT a -> DNameEnv a -> DNameEnv a

- CoreMap: }

- CoreMonad: CoreDoStrictness :: CoreToDo

- CoreMonad: instance DynFlags.HasDynFlags CoreMonad.CoreM

- CoreOpt: collectBindersPushingCo :: CoreExpr -> ([Var], CoreExpr)

- CoreOpt: exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])

- CoreOpt: exprIsLambda_maybe :: InScopeEnv -> CoreExpr -> Maybe (Var, CoreExpr, [Tickish Id])

- CoreOpt: exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal

- CoreOpt: instance Outputable.Outputable CoreOpt.SimpleOptEnv

- CoreOpt: joinPointBinding_maybe :: InBndr -> InExpr -> Maybe (InBndr, InExpr)

- CoreOpt: joinPointBindings_maybe :: [(InBndr, InExpr)] -> Maybe [(InBndr, InExpr)]

- CoreOpt: pushCoArg :: CoercionR -> CoreArg -> Maybe (CoreArg, MCoercion)

- CoreOpt: pushCoTyArg :: CoercionR -> Type -> Maybe (Type, MCoercionR)

- CoreOpt: pushCoValArg :: CoercionR -> Maybe (Coercion, MCoercion)

- CoreOpt: simpleOptExpr :: DynFlags -> CoreExpr -> CoreExpr

- CoreOpt: simpleOptExprWith :: DynFlags -> Subst -> InExpr -> OutExpr

- CoreOpt: simpleOptPgm :: DynFlags -> Module -> CoreProgram -> [CoreRule] -> IO (CoreProgram, [CoreRule])

- CoreSeq: megaSeqIdInfo :: IdInfo -> ()

- CoreSeq: seqBinds :: [Bind CoreBndr] -> ()

- CoreSeq: seqExpr :: CoreExpr -> ()

- CoreSeq: seqExprs :: [CoreExpr] -> ()

- CoreSeq: seqRuleInfo :: RuleInfo -> ()

- CoreSeq: seqRules :: [CoreRule] -> ()

- CoreSeq: seqUnfolding :: Unfolding -> ()

- CoreStats: CS :: !Int -> !Int -> !Int -> !Int -> !Int -> CoreStats

- CoreStats: [cs_co] :: CoreStats -> !Int

- CoreStats: [cs_jb] :: CoreStats -> !Int

- CoreStats: [cs_tm] :: CoreStats -> !Int

- CoreStats: [cs_ty] :: CoreStats -> !Int

- CoreStats: [cs_vb] :: CoreStats -> !Int

- CoreStats: coreBindsSize :: [CoreBind] -> Int

- CoreStats: coreBindsStats :: [CoreBind] -> CoreStats

- CoreStats: data CoreStats

- CoreStats: exprSize :: CoreExpr -> Int

- CoreStats: exprStats :: CoreExpr -> CoreStats

- CoreStats: instance Outputable.Outputable CoreStats.CoreStats

- CoreSubst: Subst :: InScopeSet -> IdSubstEnv -> TvSubstEnv -> CvSubstEnv -> Subst

- CoreSubst: addInScopeSet :: Subst -> VarSet -> Subst

- CoreSubst: cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)

- CoreSubst: cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])

- CoreSubst: cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)

- CoreSubst: cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

- CoreSubst: cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

- CoreSubst: data InScopeSet

- CoreSubst: data Subst

- CoreSubst: deShadowBinds :: CoreProgram -> CoreProgram

- CoreSubst: delBndr :: Subst -> Var -> Subst

- CoreSubst: delBndrs :: Subst -> [Var] -> Subst

- CoreSubst: emptySubst :: Subst

- CoreSubst: extendCvSubst :: Subst -> CoVar -> Coercion -> Subst

- CoreSubst: extendIdSubst :: Subst -> Id -> CoreExpr -> Subst

- CoreSubst: extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst

- CoreSubst: extendInScope :: Subst -> Var -> Subst

- CoreSubst: extendInScopeIds :: Subst -> [Id] -> Subst

- CoreSubst: extendInScopeList :: Subst -> [Var] -> Subst

- CoreSubst: extendSubst :: Subst -> Var -> CoreArg -> Subst

- CoreSubst: extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst

- CoreSubst: extendSubstWithVar :: Subst -> Var -> Var -> Subst

- CoreSubst: extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst

- CoreSubst: extendTvSubst :: Subst -> TyVar -> Type -> Subst

- CoreSubst: extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst

- CoreSubst: getTCvSubst :: Subst -> TCvSubst

- CoreSubst: instance Outputable.Outputable CoreSubst.Subst

- CoreSubst: isEmptySubst :: Subst -> Bool

- CoreSubst: isInScope :: Var -> Subst -> Bool

- CoreSubst: lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr

- CoreSubst: lookupTCvSubst :: Subst -> TyVar -> Type

- CoreSubst: mkEmptySubst :: InScopeSet -> Subst

- CoreSubst: mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst

- CoreSubst: mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst

- CoreSubst: setInScope :: Subst -> InScopeSet -> Subst

- CoreSubst: substBind :: Subst -> CoreBind -> (Subst, CoreBind)

- CoreSubst: substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)

- CoreSubst: substBndr :: Subst -> Var -> (Subst, Var)

- CoreSubst: substBndrs :: Subst -> [Var] -> (Subst, [Var])

- CoreSubst: substCo :: HasCallStack => Subst -> Coercion -> Coercion

- CoreSubst: substCoVarBndr :: Subst -> TyVar -> (Subst, TyVar)

- CoreSubst: substDVarSet :: Subst -> DVarSet -> DVarSet

- CoreSubst: substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr

- CoreSubst: substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr

- CoreSubst: substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo

- CoreSubst: substIdOcc :: Subst -> Id -> Id

- CoreSubst: substInScope :: Subst -> InScopeSet

- CoreSubst: substRecBndrs :: Subst -> [Id] -> (Subst, [Id])

- CoreSubst: substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]

- CoreSubst: substSpec :: Subst -> Id -> RuleInfo -> RuleInfo

- CoreSubst: substTickish :: Subst -> Tickish Id -> Tickish Id

- CoreSubst: substTy :: Subst -> Type -> Type

- CoreSubst: substTyVarBndr :: Subst -> TyVar -> (Subst, TyVar)

- CoreSubst: substUnfolding :: Subst -> Unfolding -> Unfolding

- CoreSubst: substUnfoldingSC :: Subst -> Unfolding -> Unfolding

- CoreSubst: type IdSubstEnv = IdEnv CoreExpr

- CoreSubst: type TvSubstEnv = TyVarEnv Type

- CoreSubst: zapSubstEnv :: Subst -> Subst

- CoreSyn: AnnApp :: AnnExpr bndr annot -> AnnExpr bndr annot -> AnnExpr' bndr annot

- CoreSyn: AnnCase :: AnnExpr bndr annot -> bndr -> Type -> [AnnAlt bndr annot] -> AnnExpr' bndr annot

- CoreSyn: AnnCast :: AnnExpr bndr annot -> (annot, Coercion) -> AnnExpr' bndr annot

- CoreSyn: AnnCoercion :: Coercion -> AnnExpr' bndr annot

- CoreSyn: AnnLam :: bndr -> AnnExpr bndr annot -> AnnExpr' bndr annot

- CoreSyn: AnnLet :: AnnBind bndr annot -> AnnExpr bndr annot -> AnnExpr' bndr annot

- CoreSyn: AnnLit :: Literal -> AnnExpr' bndr annot

- CoreSyn: AnnNonRec :: bndr -> AnnExpr bndr annot -> AnnBind bndr annot

- CoreSyn: AnnRec :: [(bndr, AnnExpr bndr annot)] -> AnnBind bndr annot

- CoreSyn: AnnTick :: Tickish Id -> AnnExpr bndr annot -> AnnExpr' bndr annot

- CoreSyn: AnnType :: Type -> AnnExpr' bndr annot

- CoreSyn: AnnVar :: Id -> AnnExpr' bndr annot

- CoreSyn: App :: Expr b -> Arg b -> Expr b

- CoreSyn: BootUnfolding :: Unfolding

- CoreSyn: Breakpoint :: !Int -> [id] -> Tickish id

- CoreSyn: BuiltinRule :: RuleName -> Name -> Int -> RuleFun -> CoreRule

- CoreSyn: Case :: Expr b -> b -> Type -> [Alt b] -> Expr b

- CoreSyn: Cast :: Expr b -> Coercion -> Expr b

- CoreSyn: Coercion :: Coercion -> Expr b

- CoreSyn: CoreUnfolding :: CoreExpr -> UnfoldingSource -> Bool -> Bool -> Bool -> Bool -> Bool -> UnfoldingGuidance -> Unfolding

- CoreSyn: CostCentreScope :: TickishScoping

- CoreSyn: DEFAULT :: AltCon

- CoreSyn: DFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding

- CoreSyn: DataAlt :: DataCon -> AltCon

- CoreSyn: HpcTick :: Module -> !Int -> Tickish id

- CoreSyn: InlineCompulsory :: UnfoldingSource

- CoreSyn: InlineRhs :: UnfoldingSource

- CoreSyn: InlineStable :: UnfoldingSource

- CoreSyn: IsOrphan :: IsOrphan

- CoreSyn: Lam :: b -> Expr b -> Expr b

- CoreSyn: Let :: Bind b -> Expr b -> Expr b

- CoreSyn: Lit :: Literal -> Expr b

- CoreSyn: LitAlt :: Literal -> AltCon

- CoreSyn: NoScope :: TickishScoping

- CoreSyn: NoUnfolding :: Unfolding

- CoreSyn: NonRec :: b -> Expr b -> Bind b

- CoreSyn: NotOrphan :: OccName -> IsOrphan

- CoreSyn: OtherCon :: [AltCon] -> Unfolding

- CoreSyn: PlaceCostCentre :: TickishPlacement

- CoreSyn: PlaceNonLam :: TickishPlacement

- CoreSyn: PlaceRuntime :: TickishPlacement

- CoreSyn: ProfNote :: CostCentre -> !Bool -> !Bool -> Tickish id

- CoreSyn: Rec :: [(b, Expr b)] -> Bind b

- CoreSyn: Rule :: RuleName -> Activation -> Name -> [Maybe Name] -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> Bool -> !Module -> !IsOrphan -> Bool -> CoreRule

- CoreSyn: RuleEnv :: RuleBase -> ModuleSet -> RuleEnv

- CoreSyn: SoftScope :: TickishScoping

- CoreSyn: SourceNote :: RealSrcSpan -> String -> Tickish id

- CoreSyn: TB :: CoreBndr -> t -> TaggedBndr t

- CoreSyn: Tick :: Tickish Id -> Expr b -> Expr b

- CoreSyn: Type :: Type -> Expr b

- CoreSyn: UnfIfGoodArgs :: [Int] -> Int -> Int -> UnfoldingGuidance

- CoreSyn: UnfNever :: UnfoldingGuidance

- CoreSyn: UnfWhen :: Arity -> Bool -> Bool -> UnfoldingGuidance

- CoreSyn: Var :: Id -> Expr b

- CoreSyn: [breakpointFVs] :: Tickish id -> [id]

- CoreSyn: [breakpointId] :: Tickish id -> !Int

- CoreSyn: [df_args] :: Unfolding -> [CoreExpr]

- CoreSyn: [df_bndrs] :: Unfolding -> [Var]

- CoreSyn: [df_con] :: Unfolding -> DataCon

- CoreSyn: [profNoteCC] :: Tickish id -> CostCentre

- CoreSyn: [profNoteCount] :: Tickish id -> !Bool

- CoreSyn: [profNoteScope] :: Tickish id -> !Bool

- CoreSyn: [re_base] :: RuleEnv -> RuleBase

- CoreSyn: [re_visible_orphs] :: RuleEnv -> ModuleSet

- CoreSyn: [ru_act] :: CoreRule -> Activation

- CoreSyn: [ru_args] :: CoreRule -> [CoreExpr]

- CoreSyn: [ru_auto] :: CoreRule -> Bool

- CoreSyn: [ru_bndrs] :: CoreRule -> [CoreBndr]

- CoreSyn: [ru_fn] :: CoreRule -> Name

- CoreSyn: [ru_local] :: CoreRule -> Bool

- CoreSyn: [ru_name] :: CoreRule -> RuleName

- CoreSyn: [ru_nargs] :: CoreRule -> Int

- CoreSyn: [ru_origin] :: CoreRule -> !Module

- CoreSyn: [ru_orphan] :: CoreRule -> !IsOrphan

- CoreSyn: [ru_rhs] :: CoreRule -> CoreExpr

- CoreSyn: [ru_rough] :: CoreRule -> [Maybe Name]

- CoreSyn: [ru_try] :: CoreRule -> RuleFun

- CoreSyn: [sourceName] :: Tickish id -> String

- CoreSyn: [sourceSpan] :: Tickish id -> RealSrcSpan

- CoreSyn: [tickId] :: Tickish id -> !Int

- CoreSyn: [tickModule] :: Tickish id -> Module

- CoreSyn: [uf_expandable] :: Unfolding -> Bool

- CoreSyn: [uf_guidance] :: Unfolding -> UnfoldingGuidance

- CoreSyn: [uf_is_conlike] :: Unfolding -> Bool

- CoreSyn: [uf_is_top] :: Unfolding -> Bool

- CoreSyn: [uf_is_value] :: Unfolding -> Bool

- CoreSyn: [uf_is_work_free] :: Unfolding -> Bool

- CoreSyn: [uf_src] :: Unfolding -> UnfoldingSource

- CoreSyn: [uf_tmpl] :: Unfolding -> CoreExpr

- CoreSyn: [ug_args] :: UnfoldingGuidance -> [Int]

- CoreSyn: [ug_arity] :: UnfoldingGuidance -> Arity

- CoreSyn: [ug_boring_ok] :: UnfoldingGuidance -> Bool

- CoreSyn: [ug_res] :: UnfoldingGuidance -> Int

- CoreSyn: [ug_size] :: UnfoldingGuidance -> Int

- CoreSyn: [ug_unsat_ok] :: UnfoldingGuidance -> Bool

- CoreSyn: applyTypeToArg :: Type -> CoreExpr -> Type

- CoreSyn: bindersOf :: Bind b -> [b]

- CoreSyn: bindersOfBinds :: [Bind b] -> [b]

- CoreSyn: bootUnfolding :: Unfolding

- CoreSyn: boringCxtNotOk :: Bool

- CoreSyn: boringCxtOk :: Bool

- CoreSyn: canUnfold :: Unfolding -> Bool

- CoreSyn: chooseOrphanAnchor :: NameSet -> IsOrphan

- CoreSyn: cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering

- CoreSyn: cmpAltCon :: AltCon -> AltCon -> Ordering

- CoreSyn: collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])

- CoreSyn: collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])

- CoreSyn: collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

- CoreSyn: collectArgs :: Expr b -> (Expr b, [Arg b])

- CoreSyn: collectArgsTicks :: (Tickish Id -> Bool) -> Expr b -> (Expr b, [Arg b], [Tickish Id])

- CoreSyn: collectBinders :: Expr b -> ([b], Expr b)

- CoreSyn: collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

- CoreSyn: collectNBinders :: Int -> Expr b -> ([b], Expr b)

- CoreSyn: collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)

- CoreSyn: collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)

- CoreSyn: data AltCon

- CoreSyn: data AnnBind bndr annot

- CoreSyn: data AnnExpr' bndr annot

- CoreSyn: data Bind b

- CoreSyn: data CoreRule

- CoreSyn: data Expr b

- CoreSyn: data IsOrphan

- CoreSyn: data RuleEnv

- CoreSyn: data TaggedBndr t

- CoreSyn: data Tickish id

- CoreSyn: data TickishPlacement

- CoreSyn: data TickishScoping

- CoreSyn: data Unfolding

- CoreSyn: data UnfoldingGuidance

- CoreSyn: data UnfoldingSource

- CoreSyn: deAnnAlt :: AnnAlt bndr annot -> Alt bndr

- CoreSyn: deAnnBind :: AnnBind b annot -> Bind b

- CoreSyn: deAnnotate :: AnnExpr bndr annot -> Expr bndr

- CoreSyn: deAnnotate' :: AnnExpr' bndr annot -> Expr bndr

- CoreSyn: deTagExpr :: TaggedExpr t -> CoreExpr

- CoreSyn: emptyRuleEnv :: RuleEnv

- CoreSyn: evaldUnfolding :: Unfolding

- CoreSyn: expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr

- CoreSyn: exprToCoercion_maybe :: CoreExpr -> Maybe Coercion

- CoreSyn: exprToType :: CoreExpr -> Type

- CoreSyn: flattenBinds :: [Bind b] -> [(b, Expr b)]

- CoreSyn: hasSomeUnfolding :: Unfolding -> Bool

- CoreSyn: infixl 4 `mkVarApps`

- CoreSyn: instance Binary.Binary CoreSyn.IsOrphan

- CoreSyn: instance Data.Data.Data CoreSyn.AltCon

- CoreSyn: instance Data.Data.Data CoreSyn.IsOrphan

- CoreSyn: instance Data.Data.Data b => Data.Data.Data (CoreSyn.Bind b)

- CoreSyn: instance Data.Data.Data b => Data.Data.Data (CoreSyn.Expr b)

- CoreSyn: instance Data.Data.Data id => Data.Data.Data (CoreSyn.Tickish id)

- CoreSyn: instance GHC.Classes.Eq CoreSyn.AltCon

- CoreSyn: instance GHC.Classes.Eq CoreSyn.TickishPlacement

- CoreSyn: instance GHC.Classes.Eq CoreSyn.TickishScoping

- CoreSyn: instance GHC.Classes.Eq CoreSyn.UnfoldingGuidance

- CoreSyn: instance GHC.Classes.Eq id => GHC.Classes.Eq (CoreSyn.Tickish id)

- CoreSyn: instance GHC.Classes.Ord CoreSyn.AltCon

- CoreSyn: instance GHC.Classes.Ord id => GHC.Classes.Ord (CoreSyn.Tickish id)

- CoreSyn: instance Outputable.Outputable CoreSyn.AltCon

- CoreSyn: instance Outputable.Outputable b => Outputable.Outputable (CoreSyn.TaggedBndr b)

- CoreSyn: isAutoRule :: CoreRule -> Bool

- CoreSyn: isBootUnfolding :: Unfolding -> Bool

- CoreSyn: isBuiltinRule :: CoreRule -> Bool

- CoreSyn: isCheapUnfolding :: Unfolding -> Bool

- CoreSyn: isCoArg :: Expr b -> Bool

- CoreSyn: isCompulsoryUnfolding :: Unfolding -> Bool

- CoreSyn: isConLikeUnfolding :: Unfolding -> Bool

- CoreSyn: isEvaldUnfolding :: Unfolding -> Bool

- CoreSyn: isExpandableUnfolding :: Unfolding -> Bool

- CoreSyn: isFragileUnfolding :: Unfolding -> Bool

- CoreSyn: isId :: Var -> Bool

- CoreSyn: isLocalRule :: CoreRule -> Bool

- CoreSyn: isOrphan :: IsOrphan -> Bool

- CoreSyn: isRuntimeArg :: CoreExpr -> Bool

- CoreSyn: isRuntimeVar :: Var -> Bool

- CoreSyn: isStableSource :: UnfoldingSource -> Bool

- CoreSyn: isStableUnfolding :: Unfolding -> Bool

- CoreSyn: isTyCoArg :: Expr b -> Bool

- CoreSyn: isTypeArg :: Expr b -> Bool

- CoreSyn: isValArg :: Expr b -> Bool

- CoreSyn: isValueUnfolding :: Unfolding -> Bool

- CoreSyn: ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool

- CoreSyn: maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr

- CoreSyn: mkApps :: Expr b -> [Arg b] -> Expr b

- CoreSyn: mkCharLit :: Char -> Expr b

- CoreSyn: mkCoApps :: Expr b -> [Coercion] -> Expr b

- CoreSyn: mkCoBind :: CoVar -> Coercion -> CoreBind

- CoreSyn: mkConApp :: DataCon -> [Arg b] -> Expr b

- CoreSyn: mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b

- CoreSyn: mkDoubleLit :: Rational -> Expr b

- CoreSyn: mkDoubleLitDouble :: Double -> Expr b

- CoreSyn: mkFloatLit :: Rational -> Expr b

- CoreSyn: mkFloatLitFloat :: Float -> Expr b

- CoreSyn: mkInt64LitInt64 :: Int64 -> Expr b

- CoreSyn: mkIntLit :: DynFlags -> Integer -> Expr b

- CoreSyn: mkIntLitInt :: DynFlags -> Int -> Expr b

- CoreSyn: mkLams :: [b] -> Expr b -> Expr b

- CoreSyn: mkLet :: Bind b -> Expr b -> Expr b

- CoreSyn: mkLetNonRec :: b -> Expr b -> Expr b -> Expr b

- CoreSyn: mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b

- CoreSyn: mkLets :: [Bind b] -> Expr b -> Expr b

- CoreSyn: mkNoCount :: Tickish id -> Tickish id

- CoreSyn: mkNoScope :: Tickish id -> Tickish id

- CoreSyn: mkOtherCon :: [AltCon] -> Unfolding

- CoreSyn: mkRuleEnv :: RuleBase -> [Module] -> RuleEnv

- CoreSyn: mkStringLit :: String -> Expr b

- CoreSyn: mkTyApps :: Expr b -> [Type] -> Expr b

- CoreSyn: mkTyArg :: Type -> Expr b

- CoreSyn: mkTyBind :: TyVar -> Type -> CoreBind

- CoreSyn: mkVarApps :: Expr b -> [Var] -> Expr b

- CoreSyn: mkWord64LitWord64 :: Word64 -> Expr b

- CoreSyn: mkWordLit :: DynFlags -> Integer -> Expr b

- CoreSyn: mkWordLitWord :: DynFlags -> Word -> Expr b

- CoreSyn: needSaturated :: Bool

- CoreSyn: neverUnfoldGuidance :: UnfoldingGuidance -> Bool

- CoreSyn: noUnfolding :: Unfolding

- CoreSyn: notOrphan :: IsOrphan -> Bool

- CoreSyn: otherCons :: Unfolding -> [AltCon]

- CoreSyn: rhssOfAlts :: [Alt b] -> [Expr b]

- CoreSyn: rhssOfBind :: Bind b -> [Expr b]

- CoreSyn: ruleActivation :: CoreRule -> Activation

- CoreSyn: ruleArity :: CoreRule -> Int

- CoreSyn: ruleIdName :: CoreRule -> Name

- CoreSyn: ruleModule :: CoreRule -> Maybe Module

- CoreSyn: ruleName :: CoreRule -> RuleName

- CoreSyn: setRuleIdName :: Name -> CoreRule -> CoreRule

- CoreSyn: stripNArgs :: Word -> Expr a -> Maybe (Expr a)

- CoreSyn: tickishCanSplit :: Tickish id -> Bool

- CoreSyn: tickishContains :: Eq b => Tickish b -> Tickish b -> Bool

- CoreSyn: tickishCounts :: Tickish id -> Bool

- CoreSyn: tickishFloatable :: Tickish id -> Bool

- CoreSyn: tickishIsCode :: Tickish id -> Bool

- CoreSyn: tickishPlace :: Tickish id -> TickishPlacement

- CoreSyn: tickishScoped :: Tickish id -> TickishScoping

- CoreSyn: tickishScopesLike :: Tickish id -> TickishScoping -> Bool

- CoreSyn: type Alt b = (AltCon, [b], Expr b)

- CoreSyn: type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)

- CoreSyn: type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)

- CoreSyn: type Arg b = Expr b

- CoreSyn: type CoreAlt = Alt CoreBndr

- CoreSyn: type CoreArg = Arg CoreBndr

- CoreSyn: type CoreBind = Bind CoreBndr

- CoreSyn: type CoreBndr = Var

- CoreSyn: type CoreExpr = Expr CoreBndr

- CoreSyn: type CoreProgram = [CoreBind]

- CoreSyn: type IdUnfoldingFun = Id -> Unfolding

- CoreSyn: type InAlt = CoreAlt

- CoreSyn: type InArg = CoreArg

- CoreSyn: type InBind = CoreBind

- CoreSyn: type InBndr = CoreBndr

- CoreSyn: type InCoVar = CoVar

- CoreSyn: type InCoercion = Coercion

- CoreSyn: type InExpr = CoreExpr

- CoreSyn: type InId = Id

- CoreSyn: type InKind = Kind

- CoreSyn: type InScopeEnv = (InScopeSet, IdUnfoldingFun)

- CoreSyn: type InTyVar = TyVar

- CoreSyn: type InType = Type

- CoreSyn: type InVar = Var

- CoreSyn: type MOutCoercion = MCoercion

- CoreSyn: type OutAlt = CoreAlt

- CoreSyn: type OutArg = CoreArg

- CoreSyn: type OutBind = CoreBind

- CoreSyn: type OutBndr = CoreBndr

- CoreSyn: type OutCoVar = CoVar

- CoreSyn: type OutCoercion = Coercion

- CoreSyn: type OutExpr = CoreExpr

- CoreSyn: type OutId = Id

- CoreSyn: type OutKind = Kind

- CoreSyn: type OutTyVar = TyVar

- CoreSyn: type OutType = Type

- CoreSyn: type OutVar = Var

- CoreSyn: type RuleBase = NameEnv [CoreRule]

- CoreSyn: type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr

- CoreSyn: type RuleName = FastString

- CoreSyn: type TaggedAlt t = Alt (TaggedBndr t)

- CoreSyn: type TaggedArg t = Arg (TaggedBndr t)

- CoreSyn: type TaggedBind t = Bind (TaggedBndr t)

- CoreSyn: type TaggedExpr t = Expr (TaggedBndr t)

- CoreSyn: unSaturatedOk :: Bool

- CoreSyn: unfoldingTemplate :: Unfolding -> CoreExpr

- CoreSyn: valArgCount :: [Arg b] -> Int

- CoreSyn: valBndrCount :: [CoreBndr] -> Int

- CoreSyn: varToCoreExpr :: CoreBndr -> Expr b

- CoreSyn: varsToCoreExprs :: [CoreBndr] -> [Expr b]

- CoreTidy: tidyExpr :: TidyEnv -> CoreExpr -> CoreExpr

- CoreTidy: tidyRules :: TidyEnv -> [CoreRule] -> [CoreRule]

- CoreTidy: tidyUnfolding :: TidyEnv -> Unfolding -> Unfolding -> Unfolding

- CoreUnfold: BoringCtxt :: CallCtxt

- CoreUnfold: CaseCtxt :: CallCtxt

- CoreUnfold: DiscArgCtxt :: CallCtxt

- CoreUnfold: NonTrivArg :: ArgSummary

- CoreUnfold: RhsCtxt :: CallCtxt

- CoreUnfold: RuleArgCtxt :: CallCtxt

- CoreUnfold: TrivArg :: ArgSummary

- CoreUnfold: ValAppCtxt :: CallCtxt

- CoreUnfold: ValueArg :: ArgSummary

- CoreUnfold: callSiteInline :: DynFlags -> Id -> Bool -> Bool -> [ArgSummary] -> CallCtxt -> Maybe CoreExpr

- CoreUnfold: certainlyWillInline :: DynFlags -> IdInfo -> Maybe Unfolding

- CoreUnfold: couldBeSmallEnoughToInline :: DynFlags -> Int -> CoreExpr -> Bool

- CoreUnfold: data ArgSummary

- CoreUnfold: data CallCtxt

- CoreUnfold: data Unfolding

- CoreUnfold: data UnfoldingGuidance

- CoreUnfold: exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])

- CoreUnfold: exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal

- CoreUnfold: inlineBoringOk :: CoreExpr -> Bool

- CoreUnfold: instance Outputable.Outputable CoreUnfold.ArgSummary

- CoreUnfold: instance Outputable.Outputable CoreUnfold.CallCtxt

- CoreUnfold: instance Outputable.Outputable CoreUnfold.ExprSize

- CoreUnfold: mkCompulsoryUnfolding :: CoreExpr -> Unfolding

- CoreUnfold: mkCoreUnfolding :: UnfoldingSource -> Bool -> CoreExpr -> UnfoldingGuidance -> Unfolding

- CoreUnfold: mkDFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding

- CoreUnfold: mkImplicitUnfolding :: DynFlags -> CoreExpr -> Unfolding

- CoreUnfold: mkInlinableUnfolding :: DynFlags -> CoreExpr -> Unfolding

- CoreUnfold: mkInlineUnfolding :: CoreExpr -> Unfolding

- CoreUnfold: mkInlineUnfoldingWithArity :: Arity -> CoreExpr -> Unfolding

- CoreUnfold: mkSimpleUnfolding :: DynFlags -> CoreExpr -> Unfolding

- CoreUnfold: mkTopUnfolding :: DynFlags -> Bool -> CoreExpr -> Unfolding

- CoreUnfold: mkUnfolding :: DynFlags -> UnfoldingSource -> Bool -> Bool -> CoreExpr -> Unfolding

- CoreUnfold: mkWorkerUnfolding :: DynFlags -> (CoreExpr -> CoreExpr) -> Unfolding -> Unfolding

- CoreUnfold: mkWwInlineRule :: DynFlags -> CoreExpr -> Arity -> Unfolding

- CoreUnfold: noUnfolding :: Unfolding

- CoreUnfold: smallEnoughToInline :: DynFlags -> Unfolding -> Bool

- CoreUnfold: specUnfolding :: DynFlags -> [Var] -> (CoreExpr -> CoreExpr) -> Arity -> Unfolding -> Unfolding

- CoreUtils: addDefault :: [(AltCon, [a], b)] -> Maybe b -> [(AltCon, [a], b)]

- CoreUtils: altsAreExhaustive :: [Alt b] -> Bool

- CoreUtils: applyTypeToArg :: Type -> CoreExpr -> Type

- CoreUtils: applyTypeToArgs :: CoreExpr -> Type -> [CoreExpr] -> Type

- CoreUtils: bindNonRec :: Id -> CoreExpr -> CoreExpr -> CoreExpr

- CoreUtils: cheapEqExpr :: Expr b -> Expr b -> Bool

- CoreUtils: cheapEqExpr' :: (Tickish Id -> Bool) -> Expr b -> Expr b -> Bool

- CoreUtils: collectMakeStaticArgs :: CoreExpr -> Maybe (CoreExpr, Type, CoreExpr, CoreExpr)

- CoreUtils: combineIdenticalAlts :: [AltCon] -> [CoreAlt] -> (Bool, [AltCon], [CoreAlt])

- CoreUtils: coreAltType :: CoreAlt -> Type

- CoreUtils: coreAltsType :: [CoreAlt] -> Type

- CoreUtils: dataConRepFSInstPat :: [FastString] -> [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])

- CoreUtils: dataConRepInstPat :: [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])

- CoreUtils: diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)] -> ([SDoc], RnEnv2)

- CoreUtils: diffExpr :: Bool -> RnEnv2 -> CoreExpr -> CoreExpr -> [SDoc]

- CoreUtils: eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool

- CoreUtils: exprIsBig :: Expr b -> Bool

- CoreUtils: exprIsBottom :: CoreExpr -> Bool

- CoreUtils: exprIsCheap :: CoreExpr -> Bool

- CoreUtils: exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool

- CoreUtils: exprIsConLike :: CoreExpr -> Bool

- CoreUtils: exprIsDupable :: DynFlags -> CoreExpr -> Bool

- CoreUtils: exprIsExpandable :: CoreExpr -> Bool

- CoreUtils: exprIsHNF :: CoreExpr -> Bool

- CoreUtils: exprIsTickedString :: CoreExpr -> Bool

- CoreUtils: exprIsTickedString_maybe :: CoreExpr -> Maybe ByteString

- CoreUtils: exprIsTopLevelBindable :: CoreExpr -> Type -> Bool

- CoreUtils: exprIsTrivial :: CoreExpr -> Bool

- CoreUtils: exprIsWorkFree :: CoreExpr -> Bool

- CoreUtils: exprOkForSideEffects :: CoreExpr -> Bool

- CoreUtils: exprOkForSpeculation :: CoreExpr -> Bool

- CoreUtils: exprToCoercion_maybe :: CoreExpr -> Maybe Coercion

- CoreUtils: exprToType :: CoreExpr -> Type

- CoreUtils: exprType :: CoreExpr -> Type

- CoreUtils: filterAlts :: TyCon -> [Type] -> [AltCon] -> [(AltCon, [Var], a)] -> ([AltCon], [(AltCon, [Var], a)])

- CoreUtils: findAlt :: AltCon -> [(AltCon, a, b)] -> Maybe (AltCon, a, b)

- CoreUtils: findDefault :: [(AltCon, [a], b)] -> ([(AltCon, [a], b)], Maybe b)

- CoreUtils: getIdFromTrivialExpr :: HasDebugCallStack => CoreExpr -> Id

- CoreUtils: getIdFromTrivialExpr_maybe :: CoreExpr -> Maybe Id

- CoreUtils: isCheapApp :: CheapAppFun

- CoreUtils: isDefaultAlt :: (AltCon, a, b) -> Bool

- CoreUtils: isEmptyTy :: Type -> Bool

- CoreUtils: isExpandableApp :: CheapAppFun

- CoreUtils: isExprLevPoly :: CoreExpr -> Bool

- CoreUtils: isJoinBind :: CoreBind -> Bool

- CoreUtils: mergeAlts :: [(AltCon, a, b)] -> [(AltCon, a, b)] -> [(AltCon, a, b)]

- CoreUtils: mkAltExpr :: AltCon -> [CoreBndr] -> [Type] -> CoreExpr

- CoreUtils: mkCast :: CoreExpr -> CoercionR -> CoreExpr

- CoreUtils: mkDefaultCase :: CoreExpr -> Id -> CoreExpr -> CoreExpr

- CoreUtils: mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr

- CoreUtils: mkTick :: Tickish Id -> CoreExpr -> CoreExpr

- CoreUtils: mkTickNoHNF :: Tickish Id -> CoreExpr -> CoreExpr

- CoreUtils: mkTicks :: [Tickish Id] -> CoreExpr -> CoreExpr

- CoreUtils: needsCaseBinding :: Type -> CoreExpr -> Bool

- CoreUtils: refineDefaultAlt :: [Unique] -> TyCon -> [Type] -> [AltCon] -> [CoreAlt] -> (Bool, [CoreAlt])

- CoreUtils: rhsIsStatic :: Platform -> (Name -> Bool) -> (LitNumType -> Integer -> Maybe CoreExpr) -> CoreExpr -> Bool

- CoreUtils: stripTicksE :: (Tickish Id -> Bool) -> Expr b -> Expr b

- CoreUtils: stripTicksT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]

- CoreUtils: stripTicksTop :: (Tickish Id -> Bool) -> Expr b -> ([Tickish Id], Expr b)

- CoreUtils: stripTicksTopE :: (Tickish Id -> Bool) -> Expr b -> Expr b

- CoreUtils: stripTicksTopT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]

- CoreUtils: tickHNFArgs :: Tickish Id -> CoreExpr -> CoreExpr

- CoreUtils: trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]

- CoreUtils: tryEtaReduce :: [Var] -> CoreExpr -> Maybe CoreExpr

- CoreUtils: type CheapAppFun = Id -> Arity -> Bool

- DataCon: buildAlgTyCon :: Name -> [TyVar] -> [Role] -> Maybe CType -> ThetaType -> AlgTyConRhs -> Bool -> AlgTyConFlav -> TyCon

- DataCon: buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind -> [Role] -> KnotTied Type -> TyCon

- Demand: botRes :: DmdResult

- Demand: cprProdRes :: [DmdType] -> DmdResult

- Demand: cprSumRes :: ConTag -> DmdResult

- Demand: data CPRResult

- Demand: instance Binary.Binary Demand.CPRResult

- Demand: instance Binary.Binary Demand.DmdResult

- Demand: instance GHC.Classes.Eq Demand.CPRResult

- Demand: instance GHC.Classes.Eq r => GHC.Classes.Eq (Demand.Termination r)

- Demand: instance GHC.Show.Show Demand.CPRResult

- Demand: instance GHC.Show.Show r => GHC.Show.Show (Demand.Termination r)

- Demand: instance Outputable.Outputable Demand.CPRResult

- Demand: instance Outputable.Outputable r => Outputable.Outputable (Demand.Termination r)

- Demand: isBotRes :: DmdResult -> Bool

- Demand: isTopRes :: DmdResult -> Bool

- Demand: returnsCPR_maybe :: DmdResult -> Maybe ConTag

- Demand: topRes :: DmdResult

- Demand: trimCPRInfo :: Bool -> Bool -> DmdResult -> DmdResult

- Demand: type DmdResult = Termination CPRResult

- Demand: vanillaCprProdRes :: Arity -> DmdResult

- DriverPhases: As :: Bool -> Phase

- DriverPhases: Cc :: Phase

- DriverPhases: Ccxx :: Phase

- DriverPhases: Cmm :: Phase

- DriverPhases: CmmCpp :: Phase

- DriverPhases: Cobjc :: Phase

- DriverPhases: Cobjcxx :: Phase

- DriverPhases: Cpp :: HscSource -> Phase

- DriverPhases: HCc :: Phase

- DriverPhases: HsBootFile :: HscSource

- DriverPhases: HsPp :: HscSource -> Phase

- DriverPhases: HsSrcFile :: HscSource

- DriverPhases: Hsc :: HscSource -> Phase

- DriverPhases: HsigFile :: HscSource

- DriverPhases: LlvmLlc :: Phase

- DriverPhases: LlvmMangle :: Phase

- DriverPhases: LlvmOpt :: Phase

- DriverPhases: MergeForeign :: Phase

- DriverPhases: StopLn :: Phase

- DriverPhases: Unlit :: HscSource -> Phase

- DriverPhases: anyHsc :: Phase

- DriverPhases: data HscSource

- DriverPhases: data Phase

- DriverPhases: eqPhase :: Phase -> Phase -> Bool

- DriverPhases: happensBefore :: DynFlags -> Phase -> Phase -> Bool

- DriverPhases: hscSourceString :: HscSource -> String

- DriverPhases: instance Binary.Binary DriverPhases.HscSource

- DriverPhases: instance GHC.Classes.Eq DriverPhases.HscSource

- DriverPhases: instance GHC.Classes.Eq DriverPhases.Phase

- DriverPhases: instance GHC.Classes.Ord DriverPhases.HscSource

- DriverPhases: instance GHC.Show.Show DriverPhases.HscSource

- DriverPhases: instance GHC.Show.Show DriverPhases.Phase

- DriverPhases: instance Outputable.Outputable DriverPhases.Phase

- DriverPhases: isBackpackishSuffix :: String -> Bool

- DriverPhases: isCishFilename :: FilePath -> Bool

- DriverPhases: isCishSuffix :: String -> Bool

- DriverPhases: isDynLibFilename :: Platform -> FilePath -> Bool

- DriverPhases: isDynLibSuffix :: Platform -> String -> Bool

- DriverPhases: isHaskellSigFilename :: FilePath -> Bool

- DriverPhases: isHaskellSigSuffix :: String -> Bool

- DriverPhases: isHaskellSrcFilename :: FilePath -> Bool

- DriverPhases: isHaskellSrcSuffix :: String -> Bool

- DriverPhases: isHaskellUserSrcFilename :: FilePath -> Bool

- DriverPhases: isHaskellUserSrcSuffix :: String -> Bool

- DriverPhases: isHaskellishFilename :: FilePath -> Bool

- DriverPhases: isHaskellishSuffix :: String -> Bool

- DriverPhases: isHaskellishTarget :: (String, Maybe Phase) -> Bool

- DriverPhases: isHsBootOrSig :: HscSource -> Bool

- DriverPhases: isHsigFile :: HscSource -> Bool

- DriverPhases: isObjectFilename :: Platform -> FilePath -> Bool

- DriverPhases: isObjectSuffix :: Platform -> String -> Bool

- DriverPhases: isSourceFilename :: FilePath -> Bool

- DriverPhases: isSourceSuffix :: String -> Bool

- DriverPhases: isStopLn :: Phase -> Bool

- DriverPhases: phaseInputExt :: Phase -> String

- DriverPhases: startPhase :: String -> Phase

- DynFlags: AixLD :: [Option] -> LinkerInfo

- DynFlags: AppleClang :: CompilerInfo

- DynFlags: AppleClang51 :: CompilerInfo

- DynFlags: CFGWeights :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> CfgWeights

- DynFlags: Clang :: CompilerInfo

- DynFlags: ClearPackageDBs :: PackageDBFlag

- DynFlags: CompManager :: GhcMode

- DynFlags: DarwinLD :: [Option] -> LinkerInfo

- DynFlags: Deployable :: DynLibLoader

- DynFlags: DistrustPackage :: String -> TrustFlag

- DynFlags: DynFlags :: GhcMode -> GhcLink -> HscTarget -> {-# UNPACK #-} !GhcNameVersion -> {-# UNPACK #-} !FileSettings -> Platform -> {-# UNPACK #-} !ToolSettings -> {-# UNPACK #-} !PlatformMisc -> PlatformConstants -> [(String, String)] -> IntegerLibrary -> LlvmConfig -> Int -> Int -> Int -> Int -> Int -> Maybe String -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Word -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Bool -> 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 -> Maybe String -> String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> IncludeSpecs -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> [LoadedPlugin] -> [StaticPlugin] -> Hooks -> FilePath -> Bool -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> Maybe [PackageDatabase] -> 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 -> LogAction -> DumpAction -> TraceAction -> 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 -> CfgWeights -> DynFlags

- DynFlags: ErrReason :: !Maybe WarningFlag -> WarnReason

- DynFlags: ExposePackage :: String -> PackageArg -> ModRenaming -> PackageFlag

- DynFlags: FileOption :: String -> String -> Option

- DynFlags: FileSettings :: FilePath -> FilePath -> Maybe FilePath -> FilePath -> String -> FilePath -> FileSettings

- DynFlags: FilesToClean :: !Set FilePath -> !Set FilePath -> FilesToClean

- DynFlags: FlagSpec :: String -> flag -> (TurnOnFlag -> DynP ()) -> GhcFlagMode -> FlagSpec flag

- DynFlags: FlushErr :: IO () -> FlushErr

- DynFlags: FlushOut :: IO () -> FlushOut

- DynFlags: GCC :: CompilerInfo

- DynFlags: GhcNameVersion :: String -> String -> GhcNameVersion

- DynFlags: GlobalPkgDb :: PkgDbRef

- DynFlags: GnuGold :: [Option] -> LinkerInfo

- DynFlags: GnuLD :: [Option] -> LinkerInfo

- DynFlags: Haskell2010 :: Language

- DynFlags: Haskell98 :: Language

- DynFlags: HidePackage :: String -> PackageFlag

- DynFlags: HscAsm :: HscTarget

- DynFlags: HscC :: HscTarget

- DynFlags: HscInterpreted :: HscTarget

- DynFlags: HscLlvm :: HscTarget

- DynFlags: HscNothing :: HscTarget

- DynFlags: IgnorePackage :: String -> IgnorePackageFlag

- DynFlags: IncludeSpecs :: [String] -> [String] -> IncludeSpecs

- DynFlags: IntegerGMP :: IntegerLibrary

- DynFlags: IntegerSimple :: IntegerLibrary

- DynFlags: LinkBinary :: GhcLink

- DynFlags: LinkDynLib :: GhcLink

- DynFlags: LinkInMemory :: GhcLink

- DynFlags: LinkStaticLib :: GhcLink

- DynFlags: LlvmConfig :: [(String, LlvmTarget)] -> [(Int, String)] -> LlvmConfig

- DynFlags: LlvmLLD :: [Option] -> LinkerInfo

- DynFlags: LlvmTarget :: String -> String -> [String] -> LlvmTarget

- DynFlags: MkDepend :: GhcMode

- DynFlags: ModRenaming :: Bool -> [(ModuleName, ModuleName)] -> ModRenaming

- DynFlags: NoGlobalPackageDB :: PackageDBFlag

- DynFlags: NoLink :: GhcLink

- DynFlags: NoProfAuto :: ProfAuto

- DynFlags: NoReason :: WarnReason

- DynFlags: NoUserPackageDB :: PackageDBFlag

- DynFlags: OneShot :: GhcMode

- DynFlags: Opt_AbstractRefHoleFits :: GeneralFlag

- DynFlags: Opt_AlignmentSanitisation :: GeneralFlag

- DynFlags: Opt_AsmShortcutting :: GeneralFlag

- DynFlags: Opt_AutoLinkPackages :: GeneralFlag

- DynFlags: Opt_AutoSccsOnIndividualCafs :: GeneralFlag

- DynFlags: Opt_BreakOnError :: GeneralFlag

- DynFlags: Opt_BreakOnException :: GeneralFlag

- DynFlags: Opt_BuildDynamicToo :: GeneralFlag

- DynFlags: Opt_BuildingCabalPackage :: GeneralFlag

- DynFlags: Opt_ByteCode :: GeneralFlag

- DynFlags: Opt_CSE :: GeneralFlag

- DynFlags: Opt_CallArity :: GeneralFlag

- DynFlags: Opt_CaseFolding :: GeneralFlag

- DynFlags: Opt_CaseMerge :: GeneralFlag

- DynFlags: Opt_CatchBottoms :: GeneralFlag

- DynFlags: Opt_CfgBlocklayout :: GeneralFlag

- DynFlags: Opt_CmmElimCommonBlocks :: GeneralFlag

- DynFlags: Opt_CmmSink :: GeneralFlag

- DynFlags: Opt_CprAnal :: GeneralFlag

- DynFlags: Opt_CrossModuleSpecialise :: GeneralFlag

- DynFlags: Opt_D_dump_BCOs :: DumpFlag

- DynFlags: Opt_D_dump_asm :: DumpFlag

- DynFlags: Opt_D_dump_asm_conflicts :: DumpFlag

- DynFlags: Opt_D_dump_asm_expanded :: DumpFlag

- DynFlags: Opt_D_dump_asm_liveness :: DumpFlag

- DynFlags: Opt_D_dump_asm_native :: DumpFlag

- DynFlags: Opt_D_dump_asm_regalloc :: DumpFlag

- DynFlags: Opt_D_dump_asm_regalloc_stages :: DumpFlag

- DynFlags: Opt_D_dump_asm_stats :: DumpFlag

- DynFlags: Opt_D_dump_call_arity :: DumpFlag

- DynFlags: Opt_D_dump_cfg_weights :: DumpFlag

- DynFlags: Opt_D_dump_cmm :: DumpFlag

- DynFlags: Opt_D_dump_cmm_caf :: DumpFlag

- DynFlags: Opt_D_dump_cmm_cbe :: DumpFlag

- DynFlags: Opt_D_dump_cmm_cfg :: DumpFlag

- DynFlags: Opt_D_dump_cmm_cps :: DumpFlag

- DynFlags: Opt_D_dump_cmm_from_stg :: DumpFlag

- DynFlags: Opt_D_dump_cmm_info :: DumpFlag

- DynFlags: Opt_D_dump_cmm_proc :: DumpFlag

- DynFlags: Opt_D_dump_cmm_procmap :: DumpFlag

- DynFlags: Opt_D_dump_cmm_raw :: DumpFlag

- DynFlags: Opt_D_dump_cmm_sink :: DumpFlag

- DynFlags: Opt_D_dump_cmm_sp :: DumpFlag

- DynFlags: Opt_D_dump_cmm_split :: DumpFlag

- DynFlags: Opt_D_dump_cmm_switch :: DumpFlag

- DynFlags: Opt_D_dump_cmm_verbose :: DumpFlag

- DynFlags: Opt_D_dump_cmm_verbose_by_proc :: DumpFlag

- DynFlags: Opt_D_dump_core_stats :: DumpFlag

- DynFlags: Opt_D_dump_cs_trace :: DumpFlag

- DynFlags: Opt_D_dump_cse :: DumpFlag

- DynFlags: Opt_D_dump_debug :: DumpFlag

- DynFlags: Opt_D_dump_deriv :: DumpFlag

- DynFlags: Opt_D_dump_ds :: DumpFlag

- DynFlags: Opt_D_dump_ds_preopt :: DumpFlag

- DynFlags: Opt_D_dump_ec_trace :: DumpFlag

- DynFlags: Opt_D_dump_exitify :: DumpFlag

- DynFlags: Opt_D_dump_foreign :: DumpFlag

- DynFlags: Opt_D_dump_hi :: DumpFlag

- DynFlags: Opt_D_dump_hi_diffs :: DumpFlag

- DynFlags: Opt_D_dump_if_trace :: DumpFlag

- DynFlags: Opt_D_dump_inlinings :: DumpFlag

- DynFlags: Opt_D_dump_json :: DumpFlag

- DynFlags: Opt_D_dump_llvm :: DumpFlag

- DynFlags: Opt_D_dump_minimal_imports :: GeneralFlag

- DynFlags: Opt_D_dump_mod_cycles :: DumpFlag

- DynFlags: Opt_D_dump_mod_map :: DumpFlag

- DynFlags: Opt_D_dump_occur_anal :: DumpFlag

- DynFlags: Opt_D_dump_opt_cmm :: DumpFlag

- DynFlags: Opt_D_dump_parsed :: DumpFlag

- DynFlags: Opt_D_dump_parsed_ast :: DumpFlag

- DynFlags: Opt_D_dump_prep :: DumpFlag

- DynFlags: Opt_D_dump_rn :: DumpFlag

- DynFlags: Opt_D_dump_rn_ast :: DumpFlag

- DynFlags: Opt_D_dump_rn_stats :: DumpFlag

- DynFlags: Opt_D_dump_rn_trace :: DumpFlag

- DynFlags: Opt_D_dump_rtti :: DumpFlag

- DynFlags: Opt_D_dump_rule_firings :: DumpFlag

- DynFlags: Opt_D_dump_rule_rewrites :: DumpFlag

- DynFlags: Opt_D_dump_rules :: DumpFlag

- DynFlags: Opt_D_dump_simpl :: DumpFlag

- DynFlags: Opt_D_dump_simpl_iterations :: DumpFlag

- DynFlags: Opt_D_dump_simpl_stats :: DumpFlag

- DynFlags: Opt_D_dump_simpl_trace :: DumpFlag

- DynFlags: Opt_D_dump_spec :: DumpFlag

- DynFlags: Opt_D_dump_splices :: DumpFlag

- DynFlags: Opt_D_dump_stg :: DumpFlag

- DynFlags: Opt_D_dump_stg_final :: DumpFlag

- DynFlags: Opt_D_dump_stg_unarised :: DumpFlag

- DynFlags: Opt_D_dump_str_signatures :: DumpFlag

- DynFlags: Opt_D_dump_stranal :: DumpFlag

- DynFlags: Opt_D_dump_tc :: DumpFlag

- DynFlags: Opt_D_dump_tc_ast :: DumpFlag

- DynFlags: Opt_D_dump_tc_trace :: DumpFlag

- DynFlags: Opt_D_dump_ticked :: DumpFlag

- DynFlags: Opt_D_dump_timings :: DumpFlag

- DynFlags: Opt_D_dump_types :: DumpFlag

- DynFlags: Opt_D_dump_view_pattern_commoning :: DumpFlag

- DynFlags: Opt_D_dump_vt_trace :: DumpFlag

- DynFlags: Opt_D_dump_worker_wrapper :: DumpFlag

- DynFlags: Opt_D_faststring_stats :: GeneralFlag

- DynFlags: Opt_D_no_debug_output :: DumpFlag

- DynFlags: Opt_D_ppr_debug :: DumpFlag

- DynFlags: Opt_D_source_stats :: DumpFlag

- DynFlags: Opt_D_th_dec_file :: DumpFlag

- DynFlags: Opt_D_verbose_core2core :: DumpFlag

- DynFlags: Opt_D_verbose_stg2stg :: DumpFlag

- DynFlags: Opt_DeferDiagnostics :: GeneralFlag

- DynFlags: Opt_DeferOutOfScopeVariables :: GeneralFlag

- DynFlags: Opt_DeferTypeErrors :: GeneralFlag

- DynFlags: Opt_DeferTypedHoles :: GeneralFlag

- DynFlags: Opt_DiagnosticsShowCaret :: GeneralFlag

- DynFlags: Opt_DictsCheap :: GeneralFlag

- DynFlags: Opt_DictsStrict :: GeneralFlag

- DynFlags: Opt_DistrustAllPackages :: GeneralFlag

- DynFlags: Opt_DmdTxDictSel :: GeneralFlag

- DynFlags: Opt_DoAnnotationLinting :: GeneralFlag

- DynFlags: Opt_DoAsmLinting :: GeneralFlag

- DynFlags: Opt_DoCmmLinting :: GeneralFlag

- DynFlags: Opt_DoCoreLinting :: GeneralFlag

- DynFlags: Opt_DoEtaReduction :: GeneralFlag

- DynFlags: Opt_DoLambdaEtaExpansion :: GeneralFlag

- DynFlags: Opt_DoStgLinting :: GeneralFlag

- DynFlags: Opt_DumpToFile :: GeneralFlag

- DynFlags: Opt_EagerBlackHoling :: GeneralFlag

- DynFlags: Opt_EmbedManifest :: GeneralFlag

- DynFlags: Opt_EnableRewriteRules :: GeneralFlag

- DynFlags: Opt_EnableThSpliceWarnings :: GeneralFlag

- DynFlags: Opt_ErrorSpans :: GeneralFlag

- DynFlags: Opt_ExcessPrecision :: GeneralFlag

- DynFlags: Opt_Exitification :: GeneralFlag

- DynFlags: Opt_ExposeAllUnfoldings :: GeneralFlag

- DynFlags: Opt_ExternalDynamicRefs :: GeneralFlag

- DynFlags: Opt_ExternalInterpreter :: GeneralFlag

- DynFlags: Opt_FastLlvm :: GeneralFlag

- DynFlags: Opt_FlatCache :: GeneralFlag

- DynFlags: Opt_FloatIn :: GeneralFlag

- DynFlags: Opt_ForceRecomp :: GeneralFlag

- DynFlags: Opt_FullLaziness :: GeneralFlag

- DynFlags: Opt_FunToThunk :: GeneralFlag

- DynFlags: Opt_G_NoOptCoercion :: GeneralFlag

- DynFlags: Opt_G_NoStateHack :: GeneralFlag

- DynFlags: Opt_GenManifest :: GeneralFlag

- DynFlags: Opt_GhciHistory :: GeneralFlag

- DynFlags: Opt_GhciLeakCheck :: GeneralFlag

- DynFlags: Opt_GhciSandbox :: GeneralFlag

- DynFlags: Opt_Haddock :: GeneralFlag

- DynFlags: Opt_HaddockOptions :: GeneralFlag

- DynFlags: Opt_HelpfulErrors :: GeneralFlag

- DynFlags: Opt_HexWordLiterals :: GeneralFlag

- DynFlags: Opt_HideAllPackages :: GeneralFlag

- DynFlags: Opt_HideAllPluginPackages :: GeneralFlag

- DynFlags: Opt_HideSourcePaths :: GeneralFlag

- DynFlags: Opt_Hpc :: GeneralFlag

- DynFlags: Opt_IgnoreAsserts :: GeneralFlag

- DynFlags: Opt_IgnoreDotGhci :: GeneralFlag

- DynFlags: Opt_IgnoreHpcChanges :: GeneralFlag

- DynFlags: Opt_IgnoreInterfacePragmas :: GeneralFlag

- DynFlags: Opt_IgnoreOptimChanges :: GeneralFlag

- DynFlags: Opt_ImplicitImportQualified :: GeneralFlag

- DynFlags: Opt_IrrefutableTuples :: GeneralFlag

- DynFlags: Opt_KeepCAFs :: GeneralFlag

- DynFlags: Opt_KeepGoing :: GeneralFlag

- DynFlags: Opt_KeepHcFiles :: GeneralFlag

- DynFlags: Opt_KeepHiDiffs :: GeneralFlag

- DynFlags: Opt_KeepHiFiles :: GeneralFlag

- DynFlags: Opt_KeepHscppFiles :: GeneralFlag

- DynFlags: Opt_KeepLlvmFiles :: GeneralFlag

- DynFlags: Opt_KeepOFiles :: GeneralFlag

- DynFlags: Opt_KeepRawTokenStream :: GeneralFlag

- DynFlags: Opt_KeepSFiles :: GeneralFlag

- DynFlags: Opt_KeepTmpFiles :: GeneralFlag

- DynFlags: Opt_KillAbsence :: GeneralFlag

- DynFlags: Opt_KillOneShot :: GeneralFlag

- DynFlags: Opt_LateDmdAnal :: GeneralFlag

- DynFlags: Opt_LateSpecialise :: GeneralFlag

- DynFlags: Opt_LiberateCase :: GeneralFlag

- DynFlags: Opt_LlvmFillUndefWithGarbage :: GeneralFlag

- DynFlags: Opt_LlvmTBAA :: GeneralFlag

- DynFlags: Opt_LocalGhciHistory :: GeneralFlag

- DynFlags: Opt_Loopification :: GeneralFlag

- DynFlags: Opt_NoHsMain :: GeneralFlag

- DynFlags: Opt_NoIt :: GeneralFlag

- DynFlags: Opt_NoLlvmMangler :: GeneralFlag

- DynFlags: Opt_NoTypeableBinds :: GeneralFlag

- DynFlags: Opt_NumConstantFolding :: GeneralFlag

- DynFlags: Opt_OmitInterfacePragmas :: GeneralFlag

- DynFlags: Opt_OmitYields :: GeneralFlag

- DynFlags: Opt_OptimalApplicativeDo :: GeneralFlag

- DynFlags: Opt_PIC :: GeneralFlag

- DynFlags: Opt_PICExecutable :: GeneralFlag

- DynFlags: Opt_PIE :: GeneralFlag

- DynFlags: Opt_PackageTrust :: GeneralFlag

- DynFlags: Opt_PedanticBottoms :: GeneralFlag

- DynFlags: Opt_PluginTrustworthy :: GeneralFlag

- DynFlags: Opt_Pp :: GeneralFlag

- DynFlags: Opt_PprCaseAsLet :: GeneralFlag

- DynFlags: Opt_PprShowTicks :: GeneralFlag

- DynFlags: Opt_PrintAxiomIncomps :: GeneralFlag

- DynFlags: Opt_PrintBindContents :: GeneralFlag

- DynFlags: Opt_PrintBindResult :: GeneralFlag

- DynFlags: Opt_PrintEqualityRelations :: GeneralFlag

- DynFlags: Opt_PrintEvldWithShow :: GeneralFlag

- DynFlags: Opt_PrintExpandedSynonyms :: GeneralFlag

- DynFlags: Opt_PrintExplicitCoercions :: GeneralFlag

- DynFlags: Opt_PrintExplicitForalls :: GeneralFlag

- DynFlags: Opt_PrintExplicitKinds :: GeneralFlag

- DynFlags: Opt_PrintExplicitRuntimeReps :: GeneralFlag

- DynFlags: Opt_PrintPotentialInstances :: GeneralFlag

- DynFlags: Opt_PrintTypecheckerElaboration :: GeneralFlag

- DynFlags: Opt_PrintUnicodeSyntax :: GeneralFlag

- DynFlags: Opt_ProfCountEntries :: GeneralFlag

- DynFlags: Opt_RPath :: GeneralFlag

- DynFlags: Opt_RegsGraph :: GeneralFlag

- DynFlags: Opt_RegsIterative :: GeneralFlag

- DynFlags: Opt_RelativeDynlibPaths :: GeneralFlag

- DynFlags: Opt_SccProfilingOn :: GeneralFlag

- DynFlags: Opt_SharedImplib :: GeneralFlag

- DynFlags: Opt_ShowDocsOfHoleFits :: GeneralFlag

- DynFlags: Opt_ShowHoleConstraints :: GeneralFlag

- DynFlags: Opt_ShowLoadedModules :: GeneralFlag

- DynFlags: Opt_ShowMatchesOfHoleFits :: GeneralFlag

- DynFlags: Opt_ShowProvOfHoleFits :: GeneralFlag

- DynFlags: Opt_ShowTypeAppOfHoleFits :: GeneralFlag

- DynFlags: Opt_ShowTypeAppVarsOfHoleFits :: GeneralFlag

- DynFlags: Opt_ShowTypeOfHoleFits :: GeneralFlag

- DynFlags: Opt_ShowValidHoleFits :: GeneralFlag

- DynFlags: Opt_ShowWarnGroups :: GeneralFlag

- DynFlags: Opt_SimplPreInlining :: GeneralFlag

- DynFlags: Opt_SingleLibFolder :: GeneralFlag

- DynFlags: Opt_SolveConstantDicts :: GeneralFlag

- DynFlags: Opt_SortBySizeHoleFits :: GeneralFlag

- DynFlags: Opt_SortBySubsumHoleFits :: GeneralFlag

- DynFlags: Opt_SortValidHoleFits :: GeneralFlag

- DynFlags: Opt_SpecConstr :: GeneralFlag

- DynFlags: Opt_SpecConstrKeen :: GeneralFlag

- DynFlags: Opt_Specialise :: GeneralFlag

- DynFlags: Opt_SpecialiseAggressively :: GeneralFlag

- DynFlags: Opt_SplitSections :: GeneralFlag

- DynFlags: Opt_StaticArgumentTransformation :: GeneralFlag

- DynFlags: Opt_StgCSE :: GeneralFlag

- DynFlags: Opt_StgLiftLams :: GeneralFlag

- DynFlags: Opt_StgStats :: GeneralFlag

- DynFlags: Opt_Strictness :: GeneralFlag

- DynFlags: Opt_SuppressCoercions :: GeneralFlag

- DynFlags: Opt_SuppressIdInfo :: GeneralFlag

- DynFlags: Opt_SuppressModulePrefixes :: GeneralFlag

- DynFlags: Opt_SuppressStgExts :: GeneralFlag

- DynFlags: Opt_SuppressTicks :: GeneralFlag

- DynFlags: Opt_SuppressTimestamps :: GeneralFlag

- DynFlags: Opt_SuppressTypeApplications :: GeneralFlag

- DynFlags: Opt_SuppressTypeSignatures :: GeneralFlag

- DynFlags: Opt_SuppressUnfoldings :: GeneralFlag

- DynFlags: Opt_SuppressUniques :: GeneralFlag

- DynFlags: Opt_SuppressVarKinds :: GeneralFlag

- DynFlags: Opt_Ticky :: GeneralFlag

- DynFlags: Opt_Ticky_Allocd :: GeneralFlag

- DynFlags: Opt_Ticky_Dyn_Thunk :: GeneralFlag

- DynFlags: Opt_Ticky_LNE :: GeneralFlag

- DynFlags: Opt_UnboxSmallStrictFields :: GeneralFlag

- DynFlags: Opt_UnboxStrictFields :: GeneralFlag

- DynFlags: Opt_UnclutterValidHoleFits :: GeneralFlag

- DynFlags: Opt_ValidateHie :: GeneralFlag

- DynFlags: Opt_VersionMacros :: GeneralFlag

- DynFlags: Opt_WarnAllMissedSpecs :: WarningFlag

- DynFlags: Opt_WarnAlternativeLayoutRuleTransitional :: WarningFlag

- DynFlags: Opt_WarnAutoOrphans :: WarningFlag

- DynFlags: Opt_WarnCPPUndef :: WarningFlag

- DynFlags: Opt_WarnDeferredOutOfScopeVariables :: WarningFlag

- DynFlags: Opt_WarnDeferredTypeErrors :: WarningFlag

- DynFlags: Opt_WarnDeprecatedFlags :: WarningFlag

- DynFlags: Opt_WarnDerivingDefaults :: WarningFlag

- DynFlags: Opt_WarnDerivingTypeable :: WarningFlag

- DynFlags: Opt_WarnDodgyExports :: WarningFlag

- DynFlags: Opt_WarnDodgyForeignImports :: WarningFlag

- DynFlags: Opt_WarnDodgyImports :: WarningFlag

- DynFlags: Opt_WarnDuplicateConstraints :: WarningFlag

- DynFlags: Opt_WarnDuplicateExports :: WarningFlag

- DynFlags: Opt_WarnEmptyEnumerations :: WarningFlag

- DynFlags: Opt_WarnHiShadows :: WarningFlag

- DynFlags: Opt_WarnIdentities :: WarningFlag

- DynFlags: Opt_WarnImplicitKindVars :: WarningFlag

- DynFlags: Opt_WarnImplicitPrelude :: WarningFlag

- DynFlags: Opt_WarnInaccessibleCode :: WarningFlag

- DynFlags: Opt_WarnIncompletePatterns :: WarningFlag

- DynFlags: Opt_WarnIncompletePatternsRecUpd :: WarningFlag

- DynFlags: Opt_WarnIncompleteUniPatterns :: WarningFlag

- DynFlags: Opt_WarnInferredSafeImports :: WarningFlag

- DynFlags: Opt_WarnInlineRuleShadowing :: WarningFlag

- DynFlags: Opt_WarnIsError :: GeneralFlag

- DynFlags: Opt_WarnMissedExtraSharedLib :: WarningFlag

- DynFlags: Opt_WarnMissedSpecs :: WarningFlag

- DynFlags: Opt_WarnMissingDerivingStrategies :: WarningFlag

- DynFlags: Opt_WarnMissingExportList :: WarningFlag

- DynFlags: Opt_WarnMissingExportedSignatures :: WarningFlag

- DynFlags: Opt_WarnMissingFields :: WarningFlag

- DynFlags: Opt_WarnMissingHomeModules :: WarningFlag

- DynFlags: Opt_WarnMissingImportList :: WarningFlag

- DynFlags: Opt_WarnMissingLocalSignatures :: WarningFlag

- DynFlags: Opt_WarnMissingMethods :: WarningFlag

- DynFlags: Opt_WarnMissingMonadFailInstances :: WarningFlag

- DynFlags: Opt_WarnMissingPatternSynonymSignatures :: WarningFlag

- DynFlags: Opt_WarnMissingSafeHaskellMode :: WarningFlag

- DynFlags: Opt_WarnMissingSignatures :: WarningFlag

- DynFlags: Opt_WarnMonomorphism :: WarningFlag

- DynFlags: Opt_WarnNameShadowing :: WarningFlag

- DynFlags: Opt_WarnNonCanonicalMonadFailInstances :: WarningFlag

- DynFlags: Opt_WarnNonCanonicalMonadInstances :: WarningFlag

- DynFlags: Opt_WarnNonCanonicalMonoidInstances :: WarningFlag

- DynFlags: Opt_WarnOrphans :: WarningFlag

- DynFlags: Opt_WarnOverflowedLiterals :: WarningFlag

- DynFlags: Opt_WarnOverlappingPatterns :: WarningFlag

- DynFlags: Opt_WarnPartialFields :: WarningFlag

- DynFlags: Opt_WarnPartialTypeSignatures :: WarningFlag

- DynFlags: Opt_WarnPrepositiveQualifiedModule :: WarningFlag

- DynFlags: Opt_WarnRedundantConstraints :: WarningFlag

- DynFlags: Opt_WarnRedundantRecordWildcards :: WarningFlag

- DynFlags: Opt_WarnSafe :: WarningFlag

- DynFlags: Opt_WarnSemigroup :: WarningFlag

- DynFlags: Opt_WarnSimplifiableClassConstraints :: WarningFlag

- DynFlags: Opt_WarnSpaceAfterBang :: WarningFlag

- DynFlags: Opt_WarnStarBinder :: WarningFlag

- DynFlags: Opt_WarnStarIsType :: WarningFlag

- DynFlags: Opt_WarnTabs :: WarningFlag

- DynFlags: Opt_WarnTrustworthySafe :: WarningFlag

- DynFlags: Opt_WarnTypeDefaults :: WarningFlag

- DynFlags: Opt_WarnTypedHoles :: WarningFlag

- DynFlags: Opt_WarnUnbangedStrictPatterns :: WarningFlag

- DynFlags: Opt_WarnUnrecognisedPragmas :: WarningFlag

- DynFlags: Opt_WarnUnrecognisedWarningFlags :: WarningFlag

- DynFlags: Opt_WarnUnsafe :: WarningFlag

- DynFlags: Opt_WarnUnsupportedCallingConventions :: WarningFlag

- DynFlags: Opt_WarnUnsupportedLlvmVersion :: WarningFlag

- DynFlags: Opt_WarnUntickedPromotedConstructors :: WarningFlag

- DynFlags: Opt_WarnUnusedDoBind :: WarningFlag

- DynFlags: Opt_WarnUnusedForalls :: WarningFlag

- DynFlags: Opt_WarnUnusedImports :: WarningFlag

- DynFlags: Opt_WarnUnusedLocalBinds :: WarningFlag

- DynFlags: Opt_WarnUnusedMatches :: WarningFlag

- DynFlags: Opt_WarnUnusedPackages :: WarningFlag

- DynFlags: Opt_WarnUnusedPatternBinds :: WarningFlag

- DynFlags: Opt_WarnUnusedRecordWildcards :: WarningFlag

- DynFlags: Opt_WarnUnusedTopBinds :: WarningFlag

- DynFlags: Opt_WarnUnusedTypePatterns :: WarningFlag

- DynFlags: Opt_WarnWarningsDeprecations :: WarningFlag

- DynFlags: Opt_WarnWrongDoBind :: WarningFlag

- DynFlags: Opt_WeightlessBlocklayout :: GeneralFlag

- DynFlags: Opt_WholeArchiveHsLibs :: GeneralFlag

- DynFlags: Opt_WorkerWrapper :: GeneralFlag

- DynFlags: Opt_WriteHie :: GeneralFlag

- DynFlags: Opt_WriteInterface :: GeneralFlag

- DynFlags: Option :: String -> Option

- DynFlags: PackageArg :: String -> PackageArg

- DynFlags: PackageDB :: PkgDbRef -> PackageDBFlag

- DynFlags: PkgDbPath :: FilePath -> PkgDbRef

- DynFlags: PlatformConstants :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Bool -> Bool -> Int -> Integer -> Integer -> Integer -> PlatformConstants

- DynFlags: PlatformMisc :: String -> String -> IntegerLibrary -> Bool -> Bool -> Bool -> String -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> PlatformMisc

- DynFlags: ProfAutoAll :: ProfAuto

- DynFlags: ProfAutoCalls :: ProfAuto

- DynFlags: ProfAutoExports :: ProfAuto

- DynFlags: ProfAutoTop :: ProfAuto

- DynFlags: Reason :: !WarningFlag -> WarnReason

- DynFlags: RtsOptsAll :: RtsOptsEnabled

- DynFlags: RtsOptsIgnore :: RtsOptsEnabled

- DynFlags: RtsOptsIgnoreAll :: RtsOptsEnabled

- DynFlags: RtsOptsNone :: RtsOptsEnabled

- DynFlags: RtsOptsSafeOnly :: RtsOptsEnabled

- DynFlags: Settings :: {-# UNPACK #-} !GhcNameVersion -> {-# UNPACK #-} !FileSettings -> Platform -> {-# UNPACK #-} !ToolSettings -> {-# UNPACK #-} !PlatformMisc -> PlatformConstants -> [(String, String)] -> Settings

- DynFlags: Sf_Ignore :: SafeHaskellMode

- DynFlags: Sf_None :: SafeHaskellMode

- DynFlags: Sf_Safe :: SafeHaskellMode

- DynFlags: Sf_SafeInferred :: SafeHaskellMode

- DynFlags: Sf_Trustworthy :: SafeHaskellMode

- DynFlags: Sf_Unsafe :: SafeHaskellMode

- DynFlags: SolarisLD :: [Option] -> LinkerInfo

- DynFlags: SystemDependent :: DynLibLoader

- DynFlags: TrustPackage :: String -> TrustFlag

- DynFlags: UnitIdArg :: UnitId -> PackageArg

- DynFlags: UnknownCC :: CompilerInfo

- DynFlags: UnknownLD :: LinkerInfo

- DynFlags: UserPkgDb :: PkgDbRef

- DynFlags: WayCustom :: String -> Way

- DynFlags: WayDebug :: Way

- DynFlags: WayDyn :: Way

- DynFlags: WayEventLog :: Way

- DynFlags: WayProf :: Way

- DynFlags: WayThreaded :: Way

- DynFlags: [avx2] :: DynFlags -> Bool

- DynFlags: [avx512cd] :: DynFlags -> Bool

- DynFlags: [avx512er] :: DynFlags -> Bool

- DynFlags: [avx512f] :: DynFlags -> Bool

- DynFlags: [avx512pf] :: DynFlags -> Bool

- DynFlags: [avx] :: DynFlags -> Bool

- DynFlags: [backEdgeBonus] :: CfgWeights -> Int

- DynFlags: [binBlobThreshold] :: DynFlags -> Word

- DynFlags: [bmiVersion] :: DynFlags -> Maybe BmiVersion

- DynFlags: [buildTag] :: DynFlags -> String

- DynFlags: [cachedPlugins] :: DynFlags -> [LoadedPlugin]

- DynFlags: [callWeight] :: CfgWeights -> Int

- DynFlags: [canGenerateDynamicToo] :: DynFlags -> IORef Bool

- DynFlags: [canUseColor] :: DynFlags -> Bool

- DynFlags: [cfgWeightInfo] :: DynFlags -> CfgWeights

- DynFlags: [cmdlineFrameworks] :: DynFlags -> [String]

- DynFlags: [cmmProcAlignment] :: DynFlags -> Maybe Int

- DynFlags: [colScheme] :: DynFlags -> Scheme

- DynFlags: [condBranchWeight] :: CfgWeights -> Int

- DynFlags: [debugLevel] :: DynFlags -> Int

- DynFlags: [depExcludeMods] :: DynFlags -> [ModuleName]

- DynFlags: [depIncludeCppDeps] :: DynFlags -> Bool

- DynFlags: [depIncludePkgDeps] :: DynFlags -> Bool

- DynFlags: [depMakefile] :: DynFlags -> FilePath

- DynFlags: [depSuffixes] :: DynFlags -> [String]

- DynFlags: [dirsToClean] :: DynFlags -> IORef (Map FilePath FilePath)

- DynFlags: [dumpDir] :: DynFlags -> Maybe String

- DynFlags: [dumpFlags] :: DynFlags -> EnumSet DumpFlag

- DynFlags: [dumpPrefixForce] :: DynFlags -> Maybe FilePath

- DynFlags: [dumpPrefix] :: DynFlags -> Maybe FilePath

- DynFlags: [dump_action] :: DynFlags -> DumpAction

- DynFlags: [dylibInstallName] :: DynFlags -> Maybe String

- DynFlags: [dynHiSuf] :: DynFlags -> String

- DynFlags: [dynLibLoader] :: DynFlags -> DynLibLoader

- DynFlags: [dynObjectSuf] :: DynFlags -> String

- DynFlags: [dynOutputFile] :: DynFlags -> Maybe String

- DynFlags: [enableTimeStats] :: DynFlags -> Bool

- DynFlags: [extensionFlags] :: DynFlags -> EnumSet Extension

- DynFlags: [extensions] :: DynFlags -> [OnOff Extension]

- DynFlags: [fatalWarningFlags] :: DynFlags -> EnumSet WarningFlag

- DynFlags: [fileSettings] :: DynFlags -> {-# UNPACK #-} !FileSettings

- DynFlags: [fileSettings_ghcUsagePath] :: FileSettings -> FilePath

- DynFlags: [fileSettings_ghciUsagePath] :: FileSettings -> FilePath

- DynFlags: [fileSettings_globalPackageDatabase] :: FileSettings -> FilePath

- DynFlags: [fileSettings_tmpDir] :: FileSettings -> String

- DynFlags: [fileSettings_toolDir] :: FileSettings -> Maybe FilePath

- DynFlags: [fileSettings_topDir] :: FileSettings -> FilePath

- DynFlags: [filesToClean] :: DynFlags -> IORef FilesToClean

- DynFlags: [flagSpecAction] :: FlagSpec flag -> TurnOnFlag -> DynP ()

- DynFlags: [flagSpecFlag] :: FlagSpec flag -> flag

- DynFlags: [flagSpecGhcMode] :: FlagSpec flag -> GhcFlagMode

- DynFlags: [flagSpecName] :: FlagSpec flag -> String

- DynFlags: [floatLamArgs] :: DynFlags -> Maybe Int

- DynFlags: [flushErr] :: DynFlags -> FlushErr

- DynFlags: [flushOut] :: DynFlags -> FlushOut

- DynFlags: [frameworkPaths] :: DynFlags -> [String]

- DynFlags: [frontendPluginOpts] :: DynFlags -> [String]

- DynFlags: [ftcCurrentModule] :: FilesToClean -> !Set FilePath

- DynFlags: [ftcGhcSession] :: FilesToClean -> !Set FilePath

- DynFlags: [generalFlags] :: DynFlags -> EnumSet GeneralFlag

- DynFlags: [generatedDumps] :: DynFlags -> IORef (Set FilePath)

- DynFlags: [ghcHeapSize] :: DynFlags -> Maybe Int

- DynFlags: [ghcLink] :: DynFlags -> GhcLink

- DynFlags: [ghcMode] :: DynFlags -> GhcMode

- DynFlags: [ghcNameVersion] :: DynFlags -> {-# UNPACK #-} !GhcNameVersion

- DynFlags: [ghcNameVersion_programName] :: GhcNameVersion -> String

- DynFlags: [ghcNameVersion_projectVersion] :: GhcNameVersion -> String

- DynFlags: [ghcVersionFile] :: DynFlags -> Maybe FilePath

- DynFlags: [ghciHistSize] :: DynFlags -> Int

- DynFlags: [ghciScripts] :: DynFlags -> [String]

- DynFlags: [haddockOptions] :: DynFlags -> Maybe String

- DynFlags: [hcSuf] :: DynFlags -> String

- DynFlags: [hiDir] :: DynFlags -> Maybe String

- DynFlags: [hiSuf] :: DynFlags -> String

- DynFlags: [hieDir] :: DynFlags -> Maybe String

- DynFlags: [hieSuf] :: DynFlags -> String

- DynFlags: [historySize] :: DynFlags -> Int

- DynFlags: [hooks] :: DynFlags -> Hooks

- DynFlags: [hpcDir] :: DynFlags -> String

- DynFlags: [hscTarget] :: DynFlags -> HscTarget

- DynFlags: [ignorePackageFlags] :: DynFlags -> [IgnorePackageFlag]

- DynFlags: [importPaths] :: DynFlags -> [FilePath]

- DynFlags: [includePathsGlobal] :: IncludeSpecs -> [String]

- DynFlags: [includePathsQuote] :: IncludeSpecs -> [String]

- DynFlags: [includePaths] :: DynFlags -> IncludeSpecs

- DynFlags: [incoherentOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [infoTablePenalty] :: CfgWeights -> Int

- DynFlags: [initialUnique] :: DynFlags -> Int

- DynFlags: [inlineCheck] :: DynFlags -> Maybe String

- DynFlags: [integerLibrary] :: DynFlags -> IntegerLibrary

- DynFlags: [interactivePrint] :: DynFlags -> Maybe String

- DynFlags: [lAttributes] :: LlvmTarget -> [String]

- DynFlags: [lCPU] :: LlvmTarget -> String

- DynFlags: [lDataLayout] :: LlvmTarget -> String

- DynFlags: [language] :: DynFlags -> Maybe Language

- DynFlags: [ldInputs] :: DynFlags -> [Option]

- DynFlags: [liberateCaseThreshold] :: DynFlags -> Maybe Int

- DynFlags: [libraryPaths] :: DynFlags -> [String]

- DynFlags: [liftLamsKnown] :: DynFlags -> Bool

- DynFlags: [liftLamsNonRecArgs] :: DynFlags -> Maybe Int

- DynFlags: [liftLamsRecArgs] :: DynFlags -> Maybe Int

- DynFlags: [likelyCondWeight] :: CfgWeights -> Int

- DynFlags: [llvmConfig] :: DynFlags -> LlvmConfig

- DynFlags: [llvmPasses] :: LlvmConfig -> [(Int, String)]

- DynFlags: [llvmTargets] :: LlvmConfig -> [(String, LlvmTarget)]

- DynFlags: [log_action] :: DynFlags -> LogAction

- DynFlags: [mainFunIs] :: DynFlags -> Maybe String

- DynFlags: [mainModIs] :: DynFlags -> Module

- DynFlags: [maxErrors] :: DynFlags -> Maybe Int

- DynFlags: [maxInlineAllocSize] :: DynFlags -> Int

- DynFlags: [maxInlineMemcpyInsns] :: DynFlags -> Int

- DynFlags: [maxInlineMemsetInsns] :: DynFlags -> Int

- DynFlags: [maxPmCheckModels] :: DynFlags -> Int

- DynFlags: [maxRefHoleFits] :: DynFlags -> Maybe Int

- DynFlags: [maxRelevantBinds] :: DynFlags -> Maybe Int

- DynFlags: [maxSimplIterations] :: DynFlags -> Int

- DynFlags: [maxUncoveredPatterns] :: DynFlags -> Int

- DynFlags: [maxValidHoleFits] :: DynFlags -> Maybe Int

- DynFlags: [maxWorkerArgs] :: DynFlags -> Int

- DynFlags: [modRenamingWithImplicit] :: ModRenaming -> Bool

- DynFlags: [modRenamings] :: ModRenaming -> [(ModuleName, ModuleName)]

- DynFlags: [newDerivOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [nextTempSuffix] :: DynFlags -> IORef Int

- DynFlags: [nextWrapperNum] :: DynFlags -> IORef (ModuleEnv Int)

- DynFlags: [objectDir] :: DynFlags -> Maybe String

- DynFlags: [objectSuf] :: DynFlags -> String

- DynFlags: [optLevel] :: DynFlags -> Int

- DynFlags: [outputFile] :: DynFlags -> Maybe String

- DynFlags: [outputHi] :: DynFlags -> Maybe String

- DynFlags: [overlapInstLoc] :: DynFlags -> SrcSpan

- DynFlags: [packageDBFlags] :: DynFlags -> [PackageDBFlag]

- DynFlags: [packageEnv] :: DynFlags -> Maybe FilePath

- DynFlags: [packageFlags] :: DynFlags -> [PackageFlag]

- DynFlags: [parMakeCount] :: DynFlags -> Maybe Int

- DynFlags: [pc_AP_STACK_SPLIM] :: PlatformConstants -> Int

- DynFlags: [pc_BITMAP_BITS_SHIFT] :: PlatformConstants -> Int

- DynFlags: [pc_BLOCKS_PER_MBLOCK] :: PlatformConstants -> Int

- DynFlags: [pc_BLOCK_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_CINT_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_CLONG_LONG_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_CLONG_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_CONTROL_GROUP_CONST_291] :: PlatformConstants -> Int

- DynFlags: [pc_DOUBLE_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_DYNAMIC_BY_DEFAULT] :: PlatformConstants -> Bool

- DynFlags: [pc_ILDV_CREATE_MASK] :: PlatformConstants -> Integer

- DynFlags: [pc_ILDV_STATE_CREATE] :: PlatformConstants -> Integer

- DynFlags: [pc_ILDV_STATE_USE] :: PlatformConstants -> Integer

- DynFlags: [pc_LDV_SHIFT] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_CHARLIKE] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Double_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Float_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_INTLIKE] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Long_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Real_Double_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Real_Float_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Real_Long_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Real_Vanilla_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Real_XMM_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_SPEC_AP_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_SPEC_SELECTEE_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_Vanilla_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MAX_XMM_REG] :: PlatformConstants -> Int

- DynFlags: [pc_MIN_CHARLIKE] :: PlatformConstants -> Int

- DynFlags: [pc_MIN_INTLIKE] :: PlatformConstants -> Int

- DynFlags: [pc_MIN_PAYLOAD_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_MUT_ARR_PTRS_CARD_BITS] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_Capability_r] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_CostCentreStack_mem_alloc] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_CostCentreStack_scc_count] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgArrBytes_bytes] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgEntCounter_allocd] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgEntCounter_allocs] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgEntCounter_entry_count] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgEntCounter_link] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgEntCounter_registeredp] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgHeader_ccs] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgHeader_ldvw] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgMutArrPtrs_ptrs] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgMutArrPtrs_size] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rCCCS] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rCurrentNursery] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rCurrentTSO] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rD1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rD2] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rD3] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rD4] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rD5] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rD6] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rF1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rF2] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rF3] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rF4] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rF5] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rF6] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rHpAlloc] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rHpLim] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rHp] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rL1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR10] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR2] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR3] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR4] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR5] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR6] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR7] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR8] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rR9] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rSpLim] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rSp] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rXMM1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rXMM2] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rXMM3] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rXMM4] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rXMM5] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rXMM6] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rYMM1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rYMM2] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rYMM3] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rYMM4] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rYMM5] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rYMM6] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rZMM1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rZMM2] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rZMM3] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rZMM4] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rZMM5] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgRegTable_rZMM6] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgSmallMutArrPtrs_ptrs] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgStack_sp] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgStack_stack] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgTSO_alloc_limit] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgTSO_cccs] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgTSO_stackobj] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_StgUpdateFrame_updatee] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_bdescr_blocks] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_bdescr_flags] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_bdescr_free] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_bdescr_start] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_stgEagerBlackholeInfo] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_stgGCEnter1] :: PlatformConstants -> Int

- DynFlags: [pc_OFFSET_stgGCFun] :: PlatformConstants -> Int

- DynFlags: [pc_PROF_HDR_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_REP_CostCentreStack_mem_alloc] :: PlatformConstants -> Int

- DynFlags: [pc_REP_CostCentreStack_scc_count] :: PlatformConstants -> Int

- DynFlags: [pc_REP_StgEntCounter_allocd] :: PlatformConstants -> Int

- DynFlags: [pc_REP_StgEntCounter_allocs] :: PlatformConstants -> Int

- DynFlags: [pc_REP_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int

- DynFlags: [pc_REP_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int

- DynFlags: [pc_RESERVED_C_STACK_BYTES] :: PlatformConstants -> Int

- DynFlags: [pc_RESERVED_STACK_WORDS] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_CostCentreStack] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_StgArrBytes_NoHdr] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_StgFunInfoExtraRev] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_StgMutArrPtrs_NoHdr] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_StgSMPThunkHeader] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_StgSmallMutArrPtrs_NoHdr] :: PlatformConstants -> Int

- DynFlags: [pc_SIZEOF_StgUpdateFrame_NoHdr] :: PlatformConstants -> Int

- DynFlags: [pc_STD_HDR_SIZE] :: PlatformConstants -> Int

- DynFlags: [pc_TAG_BITS] :: PlatformConstants -> Int

- DynFlags: [pc_TICKY_BIN_COUNT] :: PlatformConstants -> Int

- DynFlags: [pc_WORDS_BIGENDIAN] :: PlatformConstants -> Bool

- DynFlags: [pc_WORD_SIZE] :: PlatformConstants -> Int

- DynFlags: [pkgDatabase] :: DynFlags -> Maybe [PackageDatabase]

- DynFlags: [pkgState] :: DynFlags -> PackageState

- DynFlags: [pkgTrustOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [platformConstants] :: DynFlags -> PlatformConstants

- DynFlags: [platformMisc] :: DynFlags -> {-# UNPACK #-} !PlatformMisc

- DynFlags: [platformMisc_ghcDebugged] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_ghcRTSWays] :: PlatformMisc -> String

- DynFlags: [platformMisc_ghcRtsWithLibdw] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_ghcThreaded] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_ghcWithInterpreter] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_ghcWithNativeCodeGen] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_ghcWithSMP] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_integerLibraryType] :: PlatformMisc -> IntegerLibrary

- DynFlags: [platformMisc_integerLibrary] :: PlatformMisc -> String

- DynFlags: [platformMisc_leadingUnderscore] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_libFFI] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_llvmTarget] :: PlatformMisc -> String

- DynFlags: [platformMisc_tablesNextToCode] :: PlatformMisc -> Bool

- DynFlags: [platformMisc_targetPlatformString] :: PlatformMisc -> String

- DynFlags: [pluginModNameOpts] :: DynFlags -> [(ModuleName, String)]

- DynFlags: [pluginModNames] :: DynFlags -> [ModuleName]

- DynFlags: [pluginPackageFlags] :: DynFlags -> [PackageFlag]

- DynFlags: [pprCols] :: DynFlags -> Int

- DynFlags: [pprUserLength] :: DynFlags -> Int

- DynFlags: [profAuto] :: DynFlags -> ProfAuto

- DynFlags: [rawSettings] :: DynFlags -> [(String, String)]

- DynFlags: [reductionDepth] :: DynFlags -> IntWithInf

- DynFlags: [refLevelHoleFits] :: DynFlags -> Maybe Int

- DynFlags: [reverseErrors] :: DynFlags -> Bool

- DynFlags: [rtccInfo] :: DynFlags -> IORef (Maybe CompilerInfo)

- DynFlags: [rtldInfo] :: DynFlags -> IORef (Maybe LinkerInfo)

- DynFlags: [rtsOptsEnabled] :: DynFlags -> RtsOptsEnabled

- DynFlags: [rtsOptsSuggestions] :: DynFlags -> Bool

- DynFlags: [rtsOpts] :: DynFlags -> Maybe String

- DynFlags: [ruleCheck] :: DynFlags -> Maybe String

- DynFlags: [sFileSettings] :: Settings -> {-# UNPACK #-} !FileSettings

- DynFlags: [sGhcNameVersion] :: Settings -> {-# UNPACK #-} !GhcNameVersion

- DynFlags: [sPlatformConstants] :: Settings -> PlatformConstants

- DynFlags: [sPlatformMisc] :: Settings -> {-# UNPACK #-} !PlatformMisc

- DynFlags: [sRawSettings] :: Settings -> [(String, String)]

- DynFlags: [sTargetPlatform] :: Settings -> Platform

- DynFlags: [sToolSettings] :: Settings -> {-# UNPACK #-} !ToolSettings

- DynFlags: [safeHaskell] :: DynFlags -> SafeHaskellMode

- DynFlags: [safeInfer] :: DynFlags -> Bool

- DynFlags: [safeInferred] :: DynFlags -> Bool

- DynFlags: [simplPhases] :: DynFlags -> Int

- DynFlags: [simplTickFactor] :: DynFlags -> Int

- DynFlags: [solverIterations] :: DynFlags -> IntWithInf

- DynFlags: [specConstrCount] :: DynFlags -> Maybe Int

- DynFlags: [specConstrRecursive] :: DynFlags -> Int

- DynFlags: [specConstrThreshold] :: DynFlags -> Maybe Int

- DynFlags: [splitInfo] :: DynFlags -> Maybe (String, Int)

- DynFlags: [sseVersion] :: DynFlags -> Maybe SseVersion

- DynFlags: [staticPlugins] :: DynFlags -> [StaticPlugin]

- DynFlags: [strictnessBefore] :: DynFlags -> [Int]

- DynFlags: [stubDir] :: DynFlags -> Maybe String

- DynFlags: [switchWeight] :: CfgWeights -> Int

- DynFlags: [targetPlatform] :: DynFlags -> Platform

- DynFlags: [thOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [thisComponentId_] :: DynFlags -> Maybe ComponentId

- DynFlags: [thisInstalledUnitId] :: DynFlags -> InstalledUnitId

- DynFlags: [thisUnitIdInsts_] :: DynFlags -> Maybe [(ModuleName, Module)]

- DynFlags: [toolSettings] :: DynFlags -> {-# UNPACK #-} !ToolSettings

- DynFlags: [trace_action] :: DynFlags -> TraceAction

- DynFlags: [trustFlags] :: DynFlags -> [TrustFlag]

- DynFlags: [trustworthyOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [ufCreationThreshold] :: DynFlags -> Int

- DynFlags: [ufDearOp] :: DynFlags -> Int

- DynFlags: [ufDictDiscount] :: DynFlags -> Int

- DynFlags: [ufFunAppDiscount] :: DynFlags -> Int

- DynFlags: [ufKeenessFactor] :: DynFlags -> Float

- DynFlags: [ufUseThreshold] :: DynFlags -> Int

- DynFlags: [ufVeryAggressive] :: DynFlags -> Bool

- DynFlags: [uncondWeight] :: CfgWeights -> Int

- DynFlags: [uniqueIncrement] :: DynFlags -> Int

- DynFlags: [unlikelyCondWeight] :: CfgWeights -> Int

- DynFlags: [useColor] :: DynFlags -> OverridingBool

- DynFlags: [useUnicode] :: DynFlags -> Bool

- DynFlags: [verbosity] :: DynFlags -> Int

- DynFlags: [warnSafeOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [warnUnsafeOnLoc] :: DynFlags -> SrcSpan

- DynFlags: [warningFlags] :: DynFlags -> EnumSet WarningFlag

- DynFlags: [ways] :: DynFlags -> [Way]

- DynFlags: aP_STACK_SPLIM :: DynFlags -> Int

- DynFlags: addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs

- DynFlags: addPluginModuleName :: String -> DynFlags -> DynFlags

- DynFlags: addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs

- DynFlags: addWay' :: Way -> DynFlags -> DynFlags

- DynFlags: allNonDeprecatedFlags :: [String]

- DynFlags: bITMAP_BITS_SHIFT :: DynFlags -> Int

- DynFlags: bLOCKS_PER_MBLOCK :: DynFlags -> Int

- DynFlags: bLOCK_SIZE :: DynFlags -> Int

- DynFlags: bLOCK_SIZE_W :: DynFlags -> Int

- DynFlags: backendMaintainsCfg :: DynFlags -> Bool

- DynFlags: cINT_SIZE :: DynFlags -> Int

- DynFlags: cLONG_LONG_SIZE :: DynFlags -> Int

- DynFlags: cLONG_SIZE :: DynFlags -> Int

- DynFlags: cONTROL_GROUP_CONST_291 :: DynFlags -> Int

- DynFlags: canonicalizeHomeModule :: DynFlags -> ModuleName -> Module

- DynFlags: canonicalizeModuleIfHome :: DynFlags -> Module -> Module

- DynFlags: class ContainsDynFlags t

- DynFlags: class HasDynFlags m

- DynFlags: compilerInfo :: DynFlags -> [(String, String)]

- DynFlags: dOUBLE_SIZE :: DynFlags -> Int

- DynFlags: dYNAMIC_BY_DEFAULT :: DynFlags -> Bool

- DynFlags: data CfgWeights

- DynFlags: data CompilerInfo

- DynFlags: data DumpFlag

- DynFlags: data DynFlags

- DynFlags: data DynLibLoader

- DynFlags: data FileSettings

- DynFlags: data FilesToClean

- DynFlags: data FlagSpec flag

- DynFlags: data GeneralFlag

- DynFlags: data GhcLink

- DynFlags: data GhcMode

- DynFlags: data GhcNameVersion

- DynFlags: data HscTarget

- DynFlags: data IncludeSpecs

- DynFlags: data IntegerLibrary

- DynFlags: data Language

- DynFlags: data LinkerInfo

- DynFlags: data LlvmConfig

- DynFlags: data LlvmTarget

- DynFlags: data ModRenaming

- DynFlags: data Option

- DynFlags: data PackageArg

- DynFlags: data PackageDBFlag

- DynFlags: data PackageFlag

- DynFlags: data PkgDbRef

- DynFlags: data PlatformConstants

- DynFlags: data PlatformMisc

- DynFlags: data ProfAuto

- DynFlags: data RtsOptsEnabled

- DynFlags: data SafeHaskellMode

- DynFlags: data Settings

- DynFlags: data TrustFlag

- DynFlags: data WarnReason

- DynFlags: data WarningFlag

- DynFlags: data Way

- DynFlags: defaultDynFlags :: Settings -> LlvmConfig -> DynFlags

- DynFlags: defaultFatalMessager :: FatalMessager

- DynFlags: defaultFlushErr :: FlushErr

- DynFlags: defaultFlushOut :: FlushOut

- DynFlags: defaultLogAction :: LogAction

- DynFlags: defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()

- DynFlags: defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()

- DynFlags: defaultObjectTarget :: DynFlags -> HscTarget

- DynFlags: defaultWays :: Settings -> [Way]

- DynFlags: dopt :: DumpFlag -> DynFlags -> Bool

- DynFlags: dopt_set :: DynFlags -> DumpFlag -> DynFlags

- DynFlags: dopt_unset :: DynFlags -> DumpFlag -> DynFlags

- DynFlags: dynFlagDependencies :: DynFlags -> [ModuleName]

- DynFlags: dynamicGhc :: Bool

- DynFlags: dynamicOutputFile :: DynFlags -> FilePath -> FilePath

- DynFlags: dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags

- DynFlags: emptyFilesToClean :: FilesToClean

- DynFlags: extraGccViaCFlags :: DynFlags -> [String]

- DynFlags: extractDynFlags :: ContainsDynFlags t => t -> DynFlags

- DynFlags: fFlags :: [FlagSpec GeneralFlag]

- DynFlags: fLangFlags :: [FlagSpec Extension]

- DynFlags: flagsAll :: [Flag (CmdLineP DynFlags)]

- DynFlags: flagsDynamic :: [Flag (CmdLineP DynFlags)]

- DynFlags: flagsForCompletion :: Bool -> [String]

- DynFlags: flagsPackage :: [Flag (CmdLineP DynFlags)]

- DynFlags: flattenIncludes :: IncludeSpecs -> [String]

- DynFlags: getDynFlags :: HasDynFlags m => m DynFlags

- DynFlags: getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]

- DynFlags: getVerbFlags :: DynFlags -> [String]

- DynFlags: ghcUsagePath :: DynFlags -> FilePath

- DynFlags: ghciUsagePath :: DynFlags -> FilePath

- DynFlags: glasgowExtsFlags :: [Extension]

- DynFlags: globalPackageDatabasePath :: DynFlags -> FilePath

- DynFlags: gopt :: GeneralFlag -> DynFlags -> Bool

- DynFlags: gopt_set :: DynFlags -> GeneralFlag -> DynFlags

- DynFlags: gopt_unset :: DynFlags -> GeneralFlag -> DynFlags

- DynFlags: hasNoDebugOutput :: DynFlags -> Bool

- DynFlags: hasNoOptCoercion :: DynFlags -> Bool

- DynFlags: hasNoStateHack :: DynFlags -> Bool

- DynFlags: hasPprDebug :: DynFlags -> Bool

- DynFlags: iLDV_CREATE_MASK :: DynFlags -> Integer

- DynFlags: iLDV_STATE_CREATE :: DynFlags -> Integer

- DynFlags: iLDV_STATE_USE :: DynFlags -> Integer

- DynFlags: ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a

- DynFlags: initDynFlags :: DynFlags -> IO DynFlags

- DynFlags: instance (GHC.Base.Monad m, DynFlags.HasDynFlags m) => DynFlags.HasDynFlags (Control.Monad.Trans.Except.ExceptT e m)

- DynFlags: instance (GHC.Base.Monad m, DynFlags.HasDynFlags m) => DynFlags.HasDynFlags (Control.Monad.Trans.Maybe.MaybeT m)

- DynFlags: instance (GHC.Base.Monad m, DynFlags.HasDynFlags m) => DynFlags.HasDynFlags (Control.Monad.Trans.Reader.ReaderT a m)

- DynFlags: instance (GHC.Base.Monoid a, GHC.Base.Monad m, DynFlags.HasDynFlags m) => DynFlags.HasDynFlags (Control.Monad.Trans.Writer.Lazy.WriterT a m)

- DynFlags: instance GHC.Classes.Eq DynFlags.BmiVersion

- DynFlags: instance GHC.Classes.Eq DynFlags.CompilerInfo

- DynFlags: instance GHC.Classes.Eq DynFlags.Deprecation

- DynFlags: instance GHC.Classes.Eq DynFlags.DumpFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.DynLibLoader

- DynFlags: instance GHC.Classes.Eq DynFlags.GeneralFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.GhcLink

- DynFlags: instance GHC.Classes.Eq DynFlags.GhcMode

- DynFlags: instance GHC.Classes.Eq DynFlags.HscTarget

- DynFlags: instance GHC.Classes.Eq DynFlags.IgnorePackageFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.Language

- DynFlags: instance GHC.Classes.Eq DynFlags.LinkerInfo

- DynFlags: instance GHC.Classes.Eq DynFlags.ModRenaming

- DynFlags: instance GHC.Classes.Eq DynFlags.PackageArg

- DynFlags: instance GHC.Classes.Eq DynFlags.PackageDBFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.PackageFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.PkgDbRef

- DynFlags: instance GHC.Classes.Eq DynFlags.ProfAuto

- DynFlags: instance GHC.Classes.Eq DynFlags.SafeHaskellMode

- DynFlags: instance GHC.Classes.Eq DynFlags.SseVersion

- DynFlags: instance GHC.Classes.Eq DynFlags.TrustFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.WarningFlag

- DynFlags: instance GHC.Classes.Eq DynFlags.Way

- DynFlags: instance GHC.Classes.Eq a => GHC.Classes.Eq (DynFlags.OnOff a)

- DynFlags: instance GHC.Classes.Ord DynFlags.BmiVersion

- DynFlags: instance GHC.Classes.Ord DynFlags.Deprecation

- DynFlags: instance GHC.Classes.Ord DynFlags.SseVersion

- DynFlags: instance GHC.Classes.Ord DynFlags.Way

- DynFlags: instance GHC.Enum.Enum DynFlags.DumpFlag

- DynFlags: instance GHC.Enum.Enum DynFlags.GeneralFlag

- DynFlags: instance GHC.Enum.Enum DynFlags.Language

- DynFlags: instance GHC.Enum.Enum DynFlags.ProfAuto

- DynFlags: instance GHC.Enum.Enum DynFlags.WarningFlag

- DynFlags: instance GHC.Show.Show DynFlags.DumpFlag

- DynFlags: instance GHC.Show.Show DynFlags.GeneralFlag

- DynFlags: instance GHC.Show.Show DynFlags.GhcLink

- DynFlags: instance GHC.Show.Show DynFlags.HscTarget

- DynFlags: instance GHC.Show.Show DynFlags.IncludeSpecs

- DynFlags: instance GHC.Show.Show DynFlags.Language

- DynFlags: instance GHC.Show.Show DynFlags.PackageArg

- DynFlags: instance GHC.Show.Show DynFlags.RtsOptsEnabled

- DynFlags: instance GHC.Show.Show DynFlags.SafeHaskellMode

- DynFlags: instance GHC.Show.Show DynFlags.WarnReason

- DynFlags: instance GHC.Show.Show DynFlags.WarningFlag

- DynFlags: instance GHC.Show.Show DynFlags.Way

- DynFlags: instance GHC.Show.Show a => GHC.Show.Show (DynFlags.OnOff a)

- DynFlags: instance Json.ToJson DynFlags.WarnReason

- DynFlags: instance Outputable.Outputable DynFlags.GhcMode

- DynFlags: instance Outputable.Outputable DynFlags.Language

- DynFlags: instance Outputable.Outputable DynFlags.ModRenaming

- DynFlags: instance Outputable.Outputable DynFlags.PackageArg

- DynFlags: instance Outputable.Outputable DynFlags.PackageFlag

- DynFlags: instance Outputable.Outputable DynFlags.SafeHaskellMode

- DynFlags: instance Outputable.Outputable DynFlags.WarnReason

- DynFlags: instance Outputable.Outputable a => Outputable.Outputable (DynFlags.OnOff a)

- DynFlags: interpWays :: [Way]

- DynFlags: interpreterDynamic :: DynFlags -> Bool

- DynFlags: interpreterProfiled :: DynFlags -> Bool

- DynFlags: isAvx2Enabled :: DynFlags -> Bool

- DynFlags: isAvx512cdEnabled :: DynFlags -> Bool

- DynFlags: isAvx512erEnabled :: DynFlags -> Bool

- DynFlags: isAvx512fEnabled :: DynFlags -> Bool

- DynFlags: isAvx512pfEnabled :: DynFlags -> Bool

- DynFlags: isAvxEnabled :: DynFlags -> Bool

- DynFlags: isBmi2Enabled :: DynFlags -> Bool

- DynFlags: isBmiEnabled :: DynFlags -> Bool

- DynFlags: isNoLink :: GhcLink -> Bool

- DynFlags: isObjectTarget :: HscTarget -> Bool

- DynFlags: isOneShot :: GhcMode -> Bool

- DynFlags: isSse2Enabled :: DynFlags -> Bool

- DynFlags: isSse4_2Enabled :: DynFlags -> Bool

- DynFlags: isSseEnabled :: DynFlags -> Bool

- DynFlags: lDV_SHIFT :: DynFlags -> Int

- DynFlags: lang_set :: DynFlags -> Maybe Language -> DynFlags

- DynFlags: languageExtensions :: Maybe Language -> [Extension]

- DynFlags: mAX_CHARLIKE :: DynFlags -> Int

- DynFlags: mAX_Double_REG :: DynFlags -> Int

- DynFlags: mAX_Float_REG :: DynFlags -> Int

- DynFlags: mAX_INTLIKE :: DynFlags -> Int

- DynFlags: mAX_Long_REG :: DynFlags -> Int

- DynFlags: mAX_PTR_TAG :: DynFlags -> Int

- DynFlags: mAX_Real_Double_REG :: DynFlags -> Int

- DynFlags: mAX_Real_Float_REG :: DynFlags -> Int

- DynFlags: mAX_Real_Long_REG :: DynFlags -> Int

- DynFlags: mAX_Real_Vanilla_REG :: DynFlags -> Int

- DynFlags: mAX_Real_XMM_REG :: DynFlags -> Int

- DynFlags: mAX_SPEC_AP_SIZE :: DynFlags -> Int

- DynFlags: mAX_SPEC_SELECTEE_SIZE :: DynFlags -> Int

- DynFlags: mAX_Vanilla_REG :: DynFlags -> Int

- DynFlags: mAX_XMM_REG :: DynFlags -> Int

- DynFlags: mIN_CHARLIKE :: DynFlags -> Int

- DynFlags: mIN_INTLIKE :: DynFlags -> Int

- DynFlags: mIN_PAYLOAD_SIZE :: DynFlags -> Int

- DynFlags: mUT_ARR_PTRS_CARD_BITS :: DynFlags -> Int

- DynFlags: makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])

- DynFlags: mkBuildTag :: [Way] -> String

- DynFlags: newtype FlushErr

- DynFlags: newtype FlushOut

- DynFlags: newtype IgnorePackageFlag

- DynFlags: oFFSET_Capability_r :: DynFlags -> Int

- DynFlags: oFFSET_CostCentreStack_mem_alloc :: DynFlags -> Int

- DynFlags: oFFSET_CostCentreStack_scc_count :: DynFlags -> Int

- DynFlags: oFFSET_StgArrBytes_bytes :: DynFlags -> Int

- DynFlags: oFFSET_StgEntCounter_allocd :: DynFlags -> Int

- DynFlags: oFFSET_StgEntCounter_allocs :: DynFlags -> Int

- DynFlags: oFFSET_StgEntCounter_entry_count :: DynFlags -> Int

- DynFlags: oFFSET_StgEntCounter_link :: DynFlags -> Int

- DynFlags: oFFSET_StgEntCounter_registeredp :: DynFlags -> Int

- DynFlags: oFFSET_StgFunInfoExtraFwd_arity :: DynFlags -> Int

- DynFlags: oFFSET_StgFunInfoExtraRev_arity :: DynFlags -> Int

- DynFlags: oFFSET_StgHeader_ccs :: DynFlags -> Int

- DynFlags: oFFSET_StgHeader_ldvw :: DynFlags -> Int

- DynFlags: oFFSET_StgMutArrPtrs_ptrs :: DynFlags -> Int

- DynFlags: oFFSET_StgMutArrPtrs_size :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rCCCS :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rCurrentNursery :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rCurrentTSO :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rD1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rD2 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rD3 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rD4 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rD5 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rD6 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rF1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rF2 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rF3 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rF4 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rF5 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rF6 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rHp :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rHpAlloc :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rHpLim :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rL1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR10 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR2 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR3 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR4 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR5 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR6 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR7 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR8 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rR9 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rSp :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rSpLim :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rXMM1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rXMM2 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rXMM3 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rXMM4 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rXMM5 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rXMM6 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rYMM1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rYMM2 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rYMM3 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rYMM4 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rYMM5 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rYMM6 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rZMM1 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rZMM2 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rZMM3 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rZMM4 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rZMM5 :: DynFlags -> Int

- DynFlags: oFFSET_StgRegTable_rZMM6 :: DynFlags -> Int

- DynFlags: oFFSET_StgSmallMutArrPtrs_ptrs :: DynFlags -> Int

- DynFlags: oFFSET_StgStack_sp :: DynFlags -> Int

- DynFlags: oFFSET_StgStack_stack :: DynFlags -> Int

- DynFlags: oFFSET_StgTSO_alloc_limit :: DynFlags -> Int

- DynFlags: oFFSET_StgTSO_cccs :: DynFlags -> Int

- DynFlags: oFFSET_StgTSO_stackobj :: DynFlags -> Int

- DynFlags: oFFSET_StgUpdateFrame_updatee :: DynFlags -> Int

- DynFlags: oFFSET_bdescr_blocks :: DynFlags -> Int

- DynFlags: oFFSET_bdescr_flags :: DynFlags -> Int

- DynFlags: oFFSET_bdescr_free :: DynFlags -> Int

- DynFlags: oFFSET_bdescr_start :: DynFlags -> Int

- DynFlags: oFFSET_stgEagerBlackholeInfo :: DynFlags -> Int

- DynFlags: oFFSET_stgGCEnter1 :: DynFlags -> Int

- DynFlags: oFFSET_stgGCFun :: DynFlags -> Int

- DynFlags: opt_F :: DynFlags -> [String]

- DynFlags: opt_L :: DynFlags -> [String]

- DynFlags: opt_P :: DynFlags -> [String]

- DynFlags: opt_P_signature :: DynFlags -> ([String], Fingerprint)

- DynFlags: opt_a :: DynFlags -> [String]

- DynFlags: opt_c :: DynFlags -> [String]

- DynFlags: opt_cxx :: DynFlags -> [String]

- DynFlags: opt_i :: DynFlags -> [String]

- DynFlags: opt_l :: DynFlags -> [String]

- DynFlags: opt_lc :: DynFlags -> [String]

- DynFlags: opt_lcc :: DynFlags -> [String]

- DynFlags: opt_lo :: DynFlags -> [String]

- DynFlags: opt_windres :: DynFlags -> [String]

- DynFlags: optimisationFlags :: EnumSet GeneralFlag

- DynFlags: pROF_HDR_SIZE :: DynFlags -> Int

- DynFlags: packageFlagsChanged :: DynFlags -> DynFlags -> Bool

- DynFlags: packageTrustOn :: DynFlags -> Bool

- DynFlags: parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])

- 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], [Warn])

- DynFlags: pgm_F :: DynFlags -> String

- DynFlags: pgm_L :: DynFlags -> String

- DynFlags: pgm_P :: DynFlags -> (String, [Option])

- DynFlags: pgm_T :: DynFlags -> String

- DynFlags: pgm_a :: DynFlags -> (String, [Option])

- DynFlags: pgm_ar :: DynFlags -> String

- DynFlags: pgm_c :: DynFlags -> String

- DynFlags: pgm_dll :: DynFlags -> (String, [Option])

- DynFlags: pgm_i :: DynFlags -> String

- DynFlags: pgm_l :: DynFlags -> (String, [Option])

- DynFlags: pgm_lc :: DynFlags -> (String, [Option])

- DynFlags: pgm_lcc :: DynFlags -> (String, [Option])

- DynFlags: pgm_libtool :: DynFlags -> String

- DynFlags: pgm_lo :: DynFlags -> (String, [Option])

- DynFlags: pgm_ranlib :: DynFlags -> String

- DynFlags: pgm_windres :: DynFlags -> String

- DynFlags: picCCOpts :: DynFlags -> [String]

- DynFlags: picPOpts :: DynFlags -> [String]

- DynFlags: positionIndependent :: DynFlags -> Bool

- DynFlags: programName :: DynFlags -> String

- DynFlags: projectVersion :: DynFlags -> String

- DynFlags: putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()

- DynFlags: rESERVED_C_STACK_BYTES :: DynFlags -> Int

- DynFlags: rESERVED_STACK_WORDS :: DynFlags -> Int

- DynFlags: rtsIsProfiled :: Bool

- DynFlags: sExtraGccViaCFlags :: Settings -> [String]

- DynFlags: sGccSupportsNoPie :: Settings -> Bool

- DynFlags: sGhcDebugged :: Settings -> Bool

- DynFlags: sGhcRTSWays :: Settings -> String

- DynFlags: sGhcRtsWithLibdw :: Settings -> Bool

- DynFlags: sGhcThreaded :: Settings -> Bool

- DynFlags: sGhcUsagePath :: Settings -> FilePath

- DynFlags: sGhcWithInterpreter :: Settings -> Bool

- DynFlags: sGhcWithNativeCodeGen :: Settings -> Bool

- DynFlags: sGhcWithSMP :: Settings -> Bool

- DynFlags: sGhciUsagePath :: Settings -> FilePath

- DynFlags: sGlobalPackageDatabasePath :: Settings -> FilePath

- DynFlags: sIZEOF_CostCentreStack :: DynFlags -> Int

- DynFlags: sIZEOF_StgArrBytes_NoHdr :: DynFlags -> Int

- DynFlags: sIZEOF_StgFunInfoExtraRev :: DynFlags -> Int

- DynFlags: sIZEOF_StgMutArrPtrs_NoHdr :: DynFlags -> Int

- DynFlags: sIZEOF_StgSMPThunkHeader :: DynFlags -> Int

- DynFlags: sIZEOF_StgSmallMutArrPtrs_NoHdr :: DynFlags -> Int

- DynFlags: sIZEOF_StgUpdateFrame_NoHdr :: DynFlags -> Int

- DynFlags: sIntegerLibrary :: Settings -> String

- DynFlags: sIntegerLibraryType :: Settings -> IntegerLibrary

- DynFlags: sLdIsGnuLd :: Settings -> Bool

- DynFlags: sLdSupportsBuildId :: Settings -> Bool

- DynFlags: sLdSupportsCompactUnwind :: Settings -> Bool

- DynFlags: sLdSupportsFilelist :: Settings -> Bool

- DynFlags: sLeadingUnderscore :: Settings -> Bool

- DynFlags: sLibFFI :: Settings -> Bool

- DynFlags: sOpt_F :: Settings -> [String]

- DynFlags: sOpt_L :: Settings -> [String]

- DynFlags: sOpt_P :: Settings -> [String]

- DynFlags: sOpt_P_fingerprint :: Settings -> Fingerprint

- DynFlags: sOpt_a :: Settings -> [String]

- DynFlags: sOpt_c :: Settings -> [String]

- DynFlags: sOpt_cxx :: Settings -> [String]

- DynFlags: sOpt_i :: Settings -> [String]

- DynFlags: sOpt_l :: Settings -> [String]

- DynFlags: sOpt_lc :: Settings -> [String]

- DynFlags: sOpt_lcc :: Settings -> [String]

- DynFlags: sOpt_lo :: Settings -> [String]

- DynFlags: sOpt_windres :: Settings -> [String]

- DynFlags: sPgm_F :: Settings -> String

- DynFlags: sPgm_L :: Settings -> String

- DynFlags: sPgm_P :: Settings -> (String, [Option])

- DynFlags: sPgm_T :: Settings -> String

- DynFlags: sPgm_a :: Settings -> (String, [Option])

- DynFlags: sPgm_ar :: Settings -> String

- DynFlags: sPgm_c :: Settings -> String

- DynFlags: sPgm_dll :: Settings -> (String, [Option])

- DynFlags: sPgm_i :: Settings -> String

- DynFlags: sPgm_l :: Settings -> (String, [Option])

- DynFlags: sPgm_lc :: Settings -> (String, [Option])

- DynFlags: sPgm_lcc :: Settings -> (String, [Option])

- DynFlags: sPgm_libtool :: Settings -> String

- DynFlags: sPgm_lo :: Settings -> (String, [Option])

- DynFlags: sPgm_ranlib :: Settings -> String

- DynFlags: sPgm_windres :: Settings -> String

- DynFlags: sProgramName :: Settings -> String

- DynFlags: sProjectVersion :: Settings -> String

- DynFlags: sTD_HDR_SIZE :: DynFlags -> Int

- DynFlags: sTablesNextToCode :: Settings -> Bool

- DynFlags: sTargetPlatformString :: Settings -> String

- DynFlags: sTmpDir :: Settings -> String

- DynFlags: sToolDir :: Settings -> Maybe FilePath

- DynFlags: sTopDir :: Settings -> FilePath

- DynFlags: safeDirectImpsReq :: DynFlags -> Bool

- DynFlags: safeHaskellModeEnabled :: DynFlags -> Bool

- DynFlags: safeHaskellOn :: DynFlags -> Bool

- DynFlags: safeImplicitImpsReq :: DynFlags -> Bool

- DynFlags: safeImportsOn :: DynFlags -> Bool

- DynFlags: safeInferOn :: DynFlags -> Bool

- DynFlags: safeLanguageOn :: DynFlags -> Bool

- DynFlags: setFlagsFromEnvFile :: FilePath -> String -> DynP ()

- DynFlags: setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags

- DynFlags: setTmpDir :: FilePath -> DynFlags -> DynFlags

- DynFlags: setUnitId :: String -> DynFlags -> DynFlags

- DynFlags: setUnsafeGlobalDynFlags :: DynFlags -> IO ()

- DynFlags: settings :: DynFlags -> Settings

- DynFlags: shouldUseColor :: DynFlags -> Bool

- DynFlags: shouldUseHexWordLiterals :: DynFlags -> Bool

- DynFlags: showOpt :: Option -> String

- DynFlags: supportedLanguagesAndExtensions :: PlatformMini -> [String]

- DynFlags: tAG_BITS :: DynFlags -> Int

- DynFlags: tAG_MASK :: DynFlags -> Int

- DynFlags: tARGET_MAX_INT :: DynFlags -> Integer

- DynFlags: tARGET_MAX_WORD :: DynFlags -> Integer

- DynFlags: tARGET_MIN_INT :: DynFlags -> Integer

- DynFlags: tICKY_BIN_COUNT :: DynFlags -> Int

- DynFlags: tablesNextToCode :: DynFlags -> Bool

- DynFlags: targetRetainsAllBindings :: HscTarget -> Bool

- DynFlags: thisComponentId :: DynFlags -> ComponentId

- DynFlags: thisPackage :: DynFlags -> UnitId

- DynFlags: thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]

- DynFlags: tmpDir :: DynFlags -> String

- DynFlags: topDir :: DynFlags -> FilePath

- DynFlags: type FatalMessager = String -> IO ()

- DynFlags: type LogAction = DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()

- DynFlags: unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags

- DynFlags: unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

- DynFlags: unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

- DynFlags: unsafeGlobalDynFlags :: DynFlags

- DynFlags: updOptLevel :: Int -> DynFlags -> DynFlags

- DynFlags: updateWays :: DynFlags -> DynFlags

- DynFlags: useStarIsType :: DynFlags -> Bool

- DynFlags: useUnicodeSyntax :: DynFlags -> Bool

- DynFlags: versionedAppDir :: DynFlags -> MaybeT IO FilePath

- DynFlags: versionedFilePath :: DynFlags -> FilePath

- DynFlags: wORDS_BIGENDIAN :: DynFlags -> Bool

- DynFlags: wORD_SIZE :: DynFlags -> Int

- DynFlags: wORD_SIZE_IN_BITS :: DynFlags -> Int

- DynFlags: wWarningFlags :: [FlagSpec WarningFlag]

- DynFlags: warningGroups :: [(String, [WarningFlag])]

- DynFlags: warningHierarchies :: [[String]]

- DynFlags: wayGeneralFlags :: Platform -> Way -> [GeneralFlag]

- DynFlags: wayRTSOnly :: Way -> Bool

- DynFlags: wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]

- DynFlags: whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()

- DynFlags: whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()

- DynFlags: wopt :: WarningFlag -> DynFlags -> Bool

- DynFlags: wopt_fatal :: WarningFlag -> DynFlags -> Bool

- DynFlags: wopt_set :: DynFlags -> WarningFlag -> DynFlags

- DynFlags: wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags

- DynFlags: wopt_unset :: DynFlags -> WarningFlag -> DynFlags

- DynFlags: wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags

- DynFlags: wordAlignment :: DynFlags -> Alignment

- DynFlags: xFlags :: [FlagSpec Extension]

- DynFlags: xopt :: Extension -> DynFlags -> Bool

- DynFlags: xopt_set :: DynFlags -> Extension -> DynFlags

- DynFlags: xopt_set_unlessExplSpec :: Extension -> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags

- DynFlags: xopt_unset :: DynFlags -> Extension -> DynFlags

- FV: fvVarListVarSet :: FV -> ([Var], VarSet)

- GHC.Cmm: Statics :: CLabel -> [CmmStatic] -> CmmStatics

- GHC.Hs.Binds: [fun_co_fn] :: HsBindLR idL idR -> HsWrapper

- GHC.Hs.Binds: isEmptyLocalBindsPR :: HsLocalBindsLR (GhcPass a) (GhcPass b) -> Bool

- GHC.Hs.Binds: isEmptyLocalBindsTc :: HsLocalBindsLR (GhcPass a) GhcTc -> Bool

- GHC.Hs.Expr: HsCmdWrap :: XCmdWrap id -> HsWrapper -> HsCmd id -> HsCmd id

- GHC.Hs.Expr: SyntaxExpr :: HsExpr p -> [HsWrapper] -> HsWrapper -> SyntaxExpr p

- GHC.Hs.Expr: data SyntaxExpr p

- GHC.Hs.Expr: instance (Outputable.Outputable (GHC.Hs.Extension.GhcPass p), Outputable.Outputable (GHC.Hs.PlaceHolder.NameOrRdrName (GHC.Hs.Extension.GhcPass p))) => Outputable.Outputable (GHC.Hs.Expr.HsStmtContext (GHC.Hs.Extension.GhcPass p))

- GHC.Hs.Expr: instance Data.Data.Data GHC.Hs.Expr.RecordUpdTc

- GHC.Hs.Expr: instance Data.Data.Data id => Data.Data.Data (GHC.Hs.Expr.HsMatchContext id)

- GHC.Hs.Expr: instance Data.Data.Data id => Data.Data.Data (GHC.Hs.Expr.HsStmtContext id)

- GHC.Hs.Expr: instance GHC.Base.Functor GHC.Hs.Expr.HsMatchContext

- GHC.Hs.Expr: instance GHC.Base.Functor GHC.Hs.Expr.HsStmtContext

- GHC.Hs.Expr: instance GHC.Hs.Extension.OutputableBndrId p => Outputable.Outputable (GHC.Hs.Expr.SyntaxExpr (GHC.Hs.Extension.GhcPass p))

- GHC.Hs.Expr: instance Outputable.OutputableBndr id => Outputable.Outputable (GHC.Hs.Expr.HsMatchContext id)

- GHC.Hs.Extension: class Convertable a b | a -> b

- GHC.Hs.Extension: convert :: Convertable a b => a -> b

- GHC.Hs.Extension: instance Data.Typeable.Internal.Typeable c => Data.Data.Data (GHC.Hs.Extension.GhcPass c)

- GHC.Hs.Extension: instance GHC.Classes.Eq (GHC.Hs.Extension.GhcPass c)

- GHC.Hs.Extension: instance GHC.Hs.Extension.Convertable a a

- GHC.Hs.Extension: 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, XXLit a ~ XXLit b)

- GHC.Hs.Extension: type ForallXABExport (c :: * -> Constraint) (x :: *) = (c (XABE x), c (XXABExport x))

- GHC.Hs.Extension: type ForallXAmbiguousFieldOcc (c :: * -> Constraint) (x :: *) = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x))

- GHC.Hs.Extension: type ForallXAnnDecl (c :: * -> Constraint) (x :: *) = (c (XHsAnnotation x), c (XXAnnDecl x))

- GHC.Hs.Extension: type ForallXApplicativeArg (c :: * -> Constraint) (x :: *) = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x))

- GHC.Hs.Extension: type ForallXBracket (c :: * -> Constraint) (x :: *) = (c (XExpBr x), c (XPatBr x), c (XDecBrL x), c (XDecBrG x), c (XTypBr x), c (XVarBr x), c (XTExpBr x), c (XXBracket x))

- GHC.Hs.Extension: type ForallXClsInstDecl (c :: * -> Constraint) (x :: *) = (c (XCClsInstDecl x), c (XXClsInstDecl x))

- GHC.Hs.Extension: type ForallXCmd (c :: * -> Constraint) (x :: *) = (c (XCmdArrApp x), c (XCmdArrForm x), c (XCmdApp x), c (XCmdLam x), c (XCmdPar x), c (XCmdCase x), c (XCmdIf x), c (XCmdLet x), c (XCmdDo x), c (XCmdWrap x), c (XXCmd x))

- GHC.Hs.Extension: type ForallXCmdTop (c :: * -> Constraint) (x :: *) = (c (XCmdTop x), c (XXCmdTop x))

- GHC.Hs.Extension: type ForallXConDecl (c :: * -> Constraint) (x :: *) = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x))

- GHC.Hs.Extension: type ForallXConDeclField (c :: * -> Constraint) (x :: *) = (c (XConDeclField x), c (XXConDeclField x))

- GHC.Hs.Extension: type ForallXDefaultDecl (c :: * -> Constraint) (x :: *) = (c (XCDefaultDecl x), c (XXDefaultDecl x))

- GHC.Hs.Extension: type ForallXDerivDecl (c :: * -> Constraint) (x :: *) = (c (XCDerivDecl x), c (XXDerivDecl x))

- GHC.Hs.Extension: type ForallXExpr (c :: * -> Constraint) (x :: *) = (c (XVar x), c (XUnboundVar x), c (XConLikeOut x), c (XRecFld x), c (XOverLabel x), c (XIPVar x), c (XOverLitE x), c (XLitE x), c (XLam x), c (XLamCase x), c (XApp x), c (XAppTypeE x), c (XOpApp x), c (XNegApp x), c (XPar x), c (XSectionL x), c (XSectionR x), c (XExplicitTuple x), c (XExplicitSum x), c (XCase x), c (XIf x), c (XMultiIf x), c (XLet x), c (XDo x), c (XExplicitList x), c (XRecordCon x), c (XRecordUpd x), c (XExprWithTySig x), c (XArithSeq x), c (XSCC x), c (XCoreAnn x), c (XBracket x), c (XRnBracketOut x), c (XTcBracketOut x), c (XSpliceE x), c (XProc x), c (XStatic x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XWrap x), c (XXExpr x))

- GHC.Hs.Extension: type ForallXFamEqn (c :: * -> Constraint) (x :: *) (r :: *) = (c (XCFamEqn x r), c (XXFamEqn x r))

- GHC.Hs.Extension: type ForallXFamilyDecl (c :: * -> Constraint) (x :: *) = (c (XCFamilyDecl x), c (XXFamilyDecl x))

- GHC.Hs.Extension: type ForallXFamilyResultSig (c :: * -> Constraint) (x :: *) = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x))

- GHC.Hs.Extension: type ForallXFieldOcc (c :: * -> Constraint) (x :: *) = (c (XCFieldOcc x), c (XXFieldOcc x))

- GHC.Hs.Extension: type ForallXFixitySig (c :: * -> Constraint) (x :: *) = (c (XFixitySig x), c (XXFixitySig x))

- GHC.Hs.Extension: type ForallXForeignDecl (c :: * -> Constraint) (x :: *) = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x))

- GHC.Hs.Extension: type ForallXGRHS (c :: * -> Constraint) (x :: *) (b :: *) = (c (XCGRHS x b), c (XXGRHS x b))

- GHC.Hs.Extension: type ForallXGRHSs (c :: * -> Constraint) (x :: *) (b :: *) = (c (XCGRHSs x b), c (XXGRHSs x b))

- GHC.Hs.Extension: type ForallXHsBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) = (c (XFunBind x x'), c (XPatBind x x'), c (XVarBind x x'), c (XAbsBinds x x'), c (XPatSynBind x x'), c (XXHsBindsLR x x'))

- GHC.Hs.Extension: type ForallXHsDataDefn (c :: * -> Constraint) (x :: *) = (c (XCHsDataDefn x), c (XXHsDataDefn x))

- GHC.Hs.Extension: type ForallXHsDecl (c :: * -> Constraint) (x :: *) = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD x), c (XKindSigD x), c (XDefD x), c (XForD x), c (XWarningD x), c (XAnnD x), c (XRuleD x), c (XSpliceD x), c (XDocD x), c (XRoleAnnotD x), c (XXHsDecl x))

- GHC.Hs.Extension: type ForallXHsDerivingClause (c :: * -> Constraint) (x :: *) = (c (XCHsDerivingClause x), c (XXHsDerivingClause x))

- GHC.Hs.Extension: type ForallXHsGroup (c :: * -> Constraint) (x :: *) = (c (XCHsGroup x), c (XXHsGroup x))

- GHC.Hs.Extension: type ForallXHsIPBinds (c :: * -> Constraint) (x :: *) = (c (XIPBinds x), c (XXHsIPBinds x))

- GHC.Hs.Extension: type ForallXHsImplicitBndrs (c :: * -> Constraint) (x :: *) (b :: *) = (c (XHsIB x b), c (XXHsImplicitBndrs x b))

- GHC.Hs.Extension: type ForallXHsLit (c :: * -> Constraint) (x :: *) = (c (XHsChar x), c (XHsCharPrim x), c (XHsDoublePrim x), c (XHsFloatPrim x), c (XHsInt x), c (XHsInt64Prim x), c (XHsIntPrim x), c (XHsInteger x), c (XHsRat x), c (XHsString x), c (XHsStringPrim x), c (XHsWord64Prim x), c (XHsWordPrim x), c (XXLit x))

- GHC.Hs.Extension: type ForallXHsLocalBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) = (c (XHsValBinds x x'), c (XHsIPBinds x x'), c (XEmptyLocalBinds x x'), c (XXHsLocalBindsLR x x'))

- GHC.Hs.Extension: type ForallXHsWildCardBndrs (c :: * -> Constraint) (x :: *) (b :: *) = (c (XHsWC x b), c (XXHsWildCardBndrs x b))

- GHC.Hs.Extension: type ForallXIE (c :: * -> Constraint) (x :: *) = (c (XIEVar x), c (XIEThingAbs x), c (XIEThingAll x), c (XIEThingWith x), c (XIEModuleContents x), c (XIEGroup x), c (XIEDoc x), c (XIEDocNamed x), c (XXIE x))

- GHC.Hs.Extension: type ForallXIPBind (c :: * -> Constraint) (x :: *) = (c (XCIPBind x), c (XXIPBind x))

- GHC.Hs.Extension: type ForallXImportDecl (c :: * -> Constraint) (x :: *) = (c (XCImportDecl x), c (XXImportDecl x))

- GHC.Hs.Extension: type ForallXInstDecl (c :: * -> Constraint) (x :: *) = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x))

- GHC.Hs.Extension: type ForallXLHsQTyVars (c :: * -> Constraint) (x :: *) = (c (XHsQTvs x), c (XXLHsQTyVars x))

- GHC.Hs.Extension: type ForallXMatch (c :: * -> Constraint) (x :: *) (b :: *) = (c (XCMatch x b), c (XXMatch x b))

- GHC.Hs.Extension: type ForallXMatchGroup (c :: * -> Constraint) (x :: *) (b :: *) = (c (XMG x b), c (XXMatchGroup x b))

- GHC.Hs.Extension: type ForallXOverLit (c :: * -> Constraint) (x :: *) = (c (XOverLit x), c (XXOverLit x))

- GHC.Hs.Extension: type ForallXParStmtBlock (c :: * -> Constraint) (x :: *) (x' :: *) = (c (XParStmtBlock x x'), c (XXParStmtBlock x x'))

- GHC.Hs.Extension: type ForallXPat (c :: * -> Constraint) (x :: *) = (c (XWildPat x), c (XVarPat x), c (XLazyPat x), c (XAsPat x), c (XParPat x), c (XBangPat x), c (XListPat x), c (XTuplePat x), c (XSumPat x), c (XViewPat x), c (XSplicePat x), c (XLitPat x), c (XNPat x), c (XNPlusKPat x), c (XSigPat x), c (XCoPat x), c (XXPat x))

- GHC.Hs.Extension: type ForallXPatSynBind (c :: * -> Constraint) (x :: *) (x' :: *) = (c (XPSB x x'), c (XXPatSynBind x x'))

- GHC.Hs.Extension: type ForallXRoleAnnotDecl (c :: * -> Constraint) (x :: *) = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x))

- GHC.Hs.Extension: type ForallXRuleBndr (c :: * -> Constraint) (x :: *) = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x))

- GHC.Hs.Extension: type ForallXRuleDecl (c :: * -> Constraint) (x :: *) = (c (XHsRule x), c (XXRuleDecl x))

- GHC.Hs.Extension: type ForallXRuleDecls (c :: * -> Constraint) (x :: *) = (c (XCRuleDecls x), c (XXRuleDecls x))

- GHC.Hs.Extension: type ForallXSig (c :: * -> Constraint) (x :: *) = (c (XTypeSig x), c (XPatSynSig x), c (XClassOpSig x), c (XIdSig x), c (XFixSig x), c (XInlineSig x), c (XSpecSig x), c (XSpecInstSig x), c (XMinimalSig x), c (XSCCFunSig x), c (XCompleteMatchSig x), c (XXSig x))

- GHC.Hs.Extension: type ForallXSplice (c :: * -> Constraint) (x :: *) = (c (XTypedSplice x), c (XUntypedSplice x), c (XQuasiQuote x), c (XSpliced x), c (XXSplice x))

- GHC.Hs.Extension: type ForallXSpliceDecl (c :: * -> Constraint) (x :: *) = (c (XSpliceDecl x), c (XXSpliceDecl x))

- GHC.Hs.Extension: type ForallXStmtLR (c :: * -> Constraint) (x :: *) (x' :: *) (b :: *) = (c (XLastStmt x x' b), c (XBindStmt x x' b), c (XApplicativeStmt x x' b), c (XBodyStmt x x' b), c (XLetStmt x x' b), c (XParStmt x x' b), c (XTransStmt x x' b), c (XRecStmt x x' b), c (XXStmtLR x x' b))

- GHC.Hs.Extension: type ForallXTupArg (c :: * -> Constraint) (x :: *) = (c (XPresent x), c (XMissing x), c (XXTupArg x))

- GHC.Hs.Extension: type ForallXTyClDecl (c :: * -> Constraint) (x :: *) = (c (XFamDecl x), c (XSynDecl x), c (XDataDecl x), c (XClassDecl x), c (XXTyClDecl x))

- GHC.Hs.Extension: type ForallXTyClGroup (c :: * -> Constraint) (x :: *) = (c (XCTyClGroup x), c (XXTyClGroup x))

- GHC.Hs.Extension: type ForallXTyVarBndr (c :: * -> Constraint) (x :: *) = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x))

- GHC.Hs.Extension: type ForallXType (c :: * -> Constraint) (x :: *) = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy x), c (XAppKindTy x), c (XFunTy x), c (XListTy x), c (XTupleTy x), c (XSumTy x), c (XOpTy x), c (XParTy x), c (XIParamTy x), c (XStarTy x), c (XKindSig x), c (XSpliceTy x), c (XDocTy x), c (XBangTy x), c (XRecTy x), c (XExplicitListTy x), c (XExplicitTupleTy x), c (XTyLit x), c (XWildCardTy x), c (XXType x))

- GHC.Hs.Extension: type ForallXValBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) = (c (XValBinds x x'), c (XXValBindsLR x x'))

- GHC.Hs.Extension: type ForallXWarnDecl (c :: * -> Constraint) (x :: *) = (c (XWarning x), c (XXWarnDecl x))

- GHC.Hs.Extension: type ForallXWarnDecls (c :: * -> Constraint) (x :: *) = (c (XWarnings x), c (XXWarnDecls x))

- GHC.Hs.Extension: type OutputableX p = (Outputable (XIPBinds p), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn))

- GHC.Hs.Instances: instance Data.Data.Data (GHC.Hs.Expr.SyntaxExpr GHC.Hs.Extension.GhcPs)

- GHC.Hs.Instances: instance Data.Data.Data (GHC.Hs.Expr.SyntaxExpr GHC.Hs.Extension.GhcRn)

- GHC.Hs.Instances: instance Data.Data.Data (GHC.Hs.Expr.SyntaxExpr GHC.Hs.Extension.GhcTc)

- GHC.Hs.PlaceHolder: placeHolderNamesTc :: NameSet

- GHC.Hs.PlaceHolder: type family NameOrRdrName id

- GHC.Hs.Types: instance GHC.Classes.Ord (GHC.Hs.Extension.XCFieldOcc (GHC.Hs.Extension.GhcPass p)) => GHC.Classes.Ord (GHC.Hs.Types.FieldOcc (GHC.Hs.Extension.GhcPass p))

- GHC.HsToCore.PmCheck.Types: initDelta :: Delta

- GHC.Iface.Syntax: HasInfo :: [IfaceInfoItem] -> IfaceIdInfo

- GHC.Iface.Syntax: NoInfo :: IfaceIdInfo

- GHC.Iface.Syntax: data IfaceIdInfo

- GHC.Iface.Syntax: instance Binary.Binary GHC.Iface.Syntax.IfaceIdInfo

- GHC.Iface.Syntax: instance Control.DeepSeq.NFData GHC.Iface.Syntax.IfaceIdInfo

- GHC.Iface.Syntax: instance Outputable.Outputable GHC.Iface.Syntax.IfaceIdInfo

- GHC.Iface.Type: IfaceUnsafeCoerceProv :: IfaceUnivCoProv

- GHC.Runtime.Layout: ArgGen :: Liveness -> ArgDescr

- GHC.Runtime.Layout: ArgSpec :: !Int -> ArgDescr

- GHC.Runtime.Layout: ArrayPtrsRep :: !WordOff -> !WordOff -> SMRep

- GHC.Runtime.Layout: ArrayWordsRep :: !WordOff -> SMRep

- GHC.Runtime.Layout: BlackHole :: ClosureTypeInfo

- GHC.Runtime.Layout: Constr :: ConTagZ -> ConstrDescription -> ClosureTypeInfo

- GHC.Runtime.Layout: Fun :: FunArity -> ArgDescr -> ClosureTypeInfo

- GHC.Runtime.Layout: HeapRep :: IsStatic -> !WordOff -> !WordOff -> ClosureTypeInfo -> SMRep

- GHC.Runtime.Layout: IndStatic :: ClosureTypeInfo

- GHC.Runtime.Layout: RTSRep :: Int -> SMRep -> SMRep

- GHC.Runtime.Layout: SmallArrayPtrsRep :: !WordOff -> SMRep

- GHC.Runtime.Layout: StackRep :: Liveness -> SMRep

- GHC.Runtime.Layout: Thunk :: ClosureTypeInfo

- GHC.Runtime.Layout: ThunkSelector :: SelectorOffset -> ClosureTypeInfo

- GHC.Runtime.Layout: aRG_GEN :: Int

- GHC.Runtime.Layout: aRG_GEN_BIG :: Int

- GHC.Runtime.Layout: arrPtrsHdrSize :: DynFlags -> ByteOff

- GHC.Runtime.Layout: arrPtrsHdrSizeW :: DynFlags -> WordOff

- GHC.Runtime.Layout: arrPtrsRep :: DynFlags -> WordOff -> SMRep

- GHC.Runtime.Layout: arrWordsHdrSize :: DynFlags -> ByteOff

- GHC.Runtime.Layout: arrWordsHdrSizeW :: DynFlags -> WordOff

- GHC.Runtime.Layout: arrWordsRep :: DynFlags -> ByteOff -> SMRep

- GHC.Runtime.Layout: blackHoleRep :: SMRep

- GHC.Runtime.Layout: bytesToWordsRoundUp :: DynFlags -> ByteOff -> WordOff

- GHC.Runtime.Layout: card :: DynFlags -> Int -> Int

- GHC.Runtime.Layout: cardRoundUp :: DynFlags -> Int -> Int

- GHC.Runtime.Layout: cardTableSizeB :: DynFlags -> Int -> ByteOff

- GHC.Runtime.Layout: cardTableSizeW :: DynFlags -> Int -> WordOff

- GHC.Runtime.Layout: data ArgDescr

- GHC.Runtime.Layout: data ClosureTypeInfo

- GHC.Runtime.Layout: data SMRep

- GHC.Runtime.Layout: data StgHalfWord

- GHC.Runtime.Layout: data StgWord

- GHC.Runtime.Layout: fixedHdrSize :: DynFlags -> ByteOff

- GHC.Runtime.Layout: fixedHdrSizeW :: DynFlags -> WordOff

- GHC.Runtime.Layout: fromStgHalfWord :: StgHalfWord -> Integer

- GHC.Runtime.Layout: fromStgWord :: StgWord -> Integer

- GHC.Runtime.Layout: halfWordSize :: DynFlags -> ByteOff

- GHC.Runtime.Layout: halfWordSizeInBits :: DynFlags -> Int

- GHC.Runtime.Layout: hdrSize :: DynFlags -> SMRep -> ByteOff

- GHC.Runtime.Layout: hdrSizeW :: DynFlags -> SMRep -> WordOff

- GHC.Runtime.Layout: heapClosureSizeW :: DynFlags -> SMRep -> WordOff

- GHC.Runtime.Layout: indStaticRep :: SMRep

- GHC.Runtime.Layout: instance Data.Bits.Bits GHC.Runtime.Layout.StgWord

- GHC.Runtime.Layout: instance GHC.Classes.Eq GHC.Runtime.Layout.StgHalfWord

- GHC.Runtime.Layout: instance GHC.Classes.Eq GHC.Runtime.Layout.StgWord

- GHC.Runtime.Layout: instance Outputable.Outputable GHC.Runtime.Layout.ArgDescr

- GHC.Runtime.Layout: instance Outputable.Outputable GHC.Runtime.Layout.ClosureTypeInfo

- GHC.Runtime.Layout: instance Outputable.Outputable GHC.Runtime.Layout.SMRep

- GHC.Runtime.Layout: instance Outputable.Outputable GHC.Runtime.Layout.StgHalfWord

- GHC.Runtime.Layout: instance Outputable.Outputable GHC.Runtime.Layout.StgWord

- GHC.Runtime.Layout: isConRep :: SMRep -> Bool

- GHC.Runtime.Layout: isFunRep :: SMRep -> Bool

- GHC.Runtime.Layout: isStackRep :: SMRep -> Bool

- GHC.Runtime.Layout: isStaticNoCafCon :: SMRep -> Bool

- GHC.Runtime.Layout: isStaticRep :: SMRep -> IsStatic

- GHC.Runtime.Layout: isThunkRep :: SMRep -> Bool

- GHC.Runtime.Layout: mkHeapRep :: DynFlags -> IsStatic -> WordOff -> WordOff -> ClosureTypeInfo -> SMRep

- GHC.Runtime.Layout: mkRTSRep :: Int -> SMRep -> SMRep

- GHC.Runtime.Layout: mkStackRep :: [Bool] -> SMRep

- GHC.Runtime.Layout: nonHdrSize :: DynFlags -> SMRep -> ByteOff

- GHC.Runtime.Layout: nonHdrSizeW :: SMRep -> WordOff

- GHC.Runtime.Layout: profHdrSize :: DynFlags -> WordOff

- GHC.Runtime.Layout: rET_BIG :: Int

- GHC.Runtime.Layout: rET_SMALL :: Int

- GHC.Runtime.Layout: roundUpTo :: ByteOff -> ByteOff -> ByteOff

- GHC.Runtime.Layout: roundUpToWords :: DynFlags -> ByteOff -> ByteOff

- GHC.Runtime.Layout: rtsClosureType :: SMRep -> Int

- GHC.Runtime.Layout: smallArrPtrsHdrSize :: DynFlags -> ByteOff

- GHC.Runtime.Layout: smallArrPtrsHdrSizeW :: DynFlags -> WordOff

- GHC.Runtime.Layout: smallArrPtrsRep :: WordOff -> SMRep

- GHC.Runtime.Layout: thunkHdrSize :: DynFlags -> WordOff

- GHC.Runtime.Layout: toStgHalfWord :: DynFlags -> Integer -> StgHalfWord

- GHC.Runtime.Layout: toStgWord :: DynFlags -> Integer -> StgWord

- GHC.Runtime.Layout: type ByteOff = Int

- GHC.Runtime.Layout: type ConstrDescription = ByteString

- GHC.Runtime.Layout: type IsStatic = Bool

- GHC.Runtime.Layout: type Liveness = [Bool]

- GHC.Runtime.Layout: type WordOff = Int

- GHC.Runtime.Layout: wordsToBytes :: Num a => DynFlags -> a -> a

- GHC.Stg.Syntax: stgArgHasCafRefs :: StgArg -> Bool

- GHC.Stg.Syntax: topStgBindHasCafRefs :: GenStgTopBinding pass -> Bool

- GhcMonad: Ghc :: (Session -> IO a) -> Ghc a

- GhcMonad: GhcT :: (Session -> m a) -> GhcT m a

- GhcMonad: Session :: !IORef HscEnv -> Session

- GhcMonad: [unGhcT] :: GhcT m a -> Session -> m a

- GhcMonad: [unGhc] :: Ghc a -> Session -> IO a

- GhcMonad: class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m

- GhcMonad: data Session

- GhcMonad: defaultWarnErrLogger :: WarnErrLogger

- GhcMonad: getSession :: GhcMonad m => m HscEnv

- GhcMonad: getSessionDynFlags :: GhcMonad m => m DynFlags

- GhcMonad: instance Control.Monad.Fix.MonadFix GhcMonad.Ghc

- GhcMonad: instance Control.Monad.IO.Class.MonadIO GhcMonad.Ghc

- GhcMonad: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (GhcMonad.GhcT m)

- GhcMonad: instance Control.Monad.IO.Class.MonadIO m => DynFlags.HasDynFlags (GhcMonad.GhcT m)

- GhcMonad: instance DynFlags.HasDynFlags GhcMonad.Ghc

- GhcMonad: instance Exception.ExceptionMonad GhcMonad.Ghc

- GhcMonad: instance Exception.ExceptionMonad m => Exception.ExceptionMonad (GhcMonad.GhcT m)

- GhcMonad: instance Exception.ExceptionMonad m => GhcMonad.GhcMonad (GhcMonad.GhcT m)

- GhcMonad: instance GHC.Base.Applicative GhcMonad.Ghc

- GhcMonad: instance GHC.Base.Applicative m => GHC.Base.Applicative (GhcMonad.GhcT m)

- GhcMonad: instance GHC.Base.Functor GhcMonad.Ghc

- GhcMonad: instance GHC.Base.Functor m => GHC.Base.Functor (GhcMonad.GhcT m)

- GhcMonad: instance GHC.Base.Monad GhcMonad.Ghc

- GhcMonad: instance GHC.Base.Monad m => GHC.Base.Monad (GhcMonad.GhcT m)

- GhcMonad: instance GhcMonad.GhcMonad GhcMonad.Ghc

- GhcMonad: liftGhcT :: m a -> GhcT m a

- GhcMonad: liftIO :: MonadIO m => IO a -> m a

- GhcMonad: logWarnings :: GhcMonad m => WarningMessages -> m ()

- GhcMonad: modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()

- GhcMonad: newtype Ghc a

- GhcMonad: newtype GhcT m a

- GhcMonad: printException :: GhcMonad m => SourceError -> m ()

- GhcMonad: reflectGhc :: Ghc a -> Session -> IO a

- GhcMonad: reifyGhc :: (Session -> IO a) -> Ghc a

- GhcMonad: setSession :: GhcMonad m => HscEnv -> m ()

- GhcMonad: type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()

- GhcMonad: withSession :: GhcMonad m => (HscEnv -> m a) -> m a

- GhcMonad: withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a

- Hooks: cmmToRawCmmHook :: Hooks -> Maybe (DynFlags -> Maybe Module -> Stream IO CmmGroup () -> IO (Stream IO RawCmmGroup ()))

- Hooks: createIservProcessHook :: Hooks -> Maybe (CreateProcess -> IO ProcessHandle)

- Hooks: data Hooks

- Hooks: dsForeignsHook :: Hooks -> Maybe ([LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))

- Hooks: emptyHooks :: Hooks

- Hooks: getHooked :: (Functor f, HasDynFlags f) => (Hooks -> Maybe a) -> a -> f a

- Hooks: getValueSafelyHook :: Hooks -> Maybe (HscEnv -> Name -> Type -> IO (Maybe HValue))

- Hooks: ghcPrimIfaceHook :: Hooks -> Maybe ModIface

- Hooks: hscCompileCoreExprHook :: Hooks -> Maybe (HscEnv -> SrcSpan -> CoreExpr -> IO ForeignHValue)

- Hooks: hscFrontendHook :: Hooks -> Maybe (ModSummary -> Hsc FrontendResult)

- Hooks: linkHook :: Hooks -> Maybe (GhcLink -> DynFlags -> Bool -> HomePackageTable -> IO SuccessFlag)

- Hooks: lookupHook :: (Hooks -> Maybe a) -> a -> DynFlags -> a

- Hooks: runMetaHook :: Hooks -> Maybe (MetaHook TcM)

- Hooks: runPhaseHook :: Hooks -> Maybe (PhasePlus -> FilePath -> DynFlags -> CompPipeline (PhasePlus, FilePath))

- Hooks: runRnSpliceHook :: Hooks -> Maybe (HsSplice GhcRn -> RnM (HsSplice GhcRn))

- Hooks: stgToCmmHook :: Hooks -> Maybe (DynFlags -> Module -> [TyCon] -> CollectedCCs -> [CgStgTopBinding] -> HpcInfo -> Stream IO CmmGroup ())

- Hooks: tcForeignExportsHook :: Hooks -> Maybe ([LForeignDecl GhcRn] -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt))

- Hooks: tcForeignImportsHook :: Hooks -> Maybe ([LForeignDecl GhcRn] -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt))

- HscTypes: ACoAxiom :: CoAxiom Branched -> TyThing

- HscTypes: AConLike :: ConLike -> TyThing

- HscTypes: ATyCon :: TyCon -> TyThing

- HscTypes: AnId :: Id -> TyThing

- HscTypes: BCOs :: CompiledByteCode -> [SptEntry] -> Unlinked

- HscTypes: CgGuts :: !Module -> [TyCon] -> CoreProgram -> !ForeignStubs -> ![(ForeignSrcLang, FilePath)] -> ![InstalledUnitId] -> !HpcInfo -> !Maybe ModBreaks -> [SptEntry] -> CgGuts

- HscTypes: CompleteMatch :: [Name] -> Name -> CompleteMatch

- HscTypes: DeprecatedTxt :: Located SourceText -> [Located StringLiteral] -> WarningTxt

- HscTypes: Deps :: [(ModuleName, IsBootInterface)] -> [(InstalledUnitId, Bool)] -> [Module] -> [Module] -> [ModuleName] -> Dependencies

- HscTypes: DotA :: FilePath -> Unlinked

- HscTypes: DotDLL :: FilePath -> Unlinked

- HscTypes: DotO :: FilePath -> Unlinked

- HscTypes: EPS :: !ModuleNameEnv (ModuleName, IsBootInterface) -> !PackageIfaceTable -> InstalledModuleEnv (UniqDSet ModuleName) -> !PackageTypeEnv -> !PackageInstEnv -> !PackageFamInstEnv -> !PackageRuleBase -> !PackageAnnEnv -> !PackageCompleteMatchMap -> !ModuleEnv FamInstEnv -> !EpsStats -> ExternalPackageState

- HscTypes: EpsStats :: !Int -> EpsStats

- HscTypes: FixItem :: OccName -> Fixity -> FixItem

- HscTypes: ForeignStubs :: SDoc -> SDoc -> ForeignStubs

- HscTypes: Found :: ModLocation -> Module -> FindResult

- HscTypes: FoundMultiple :: [(Module, ModuleOrigin)] -> FindResult

- HscTypes: HomeModInfo :: !ModIface -> !ModDetails -> !Maybe Linkable -> HomeModInfo

- HscTypes: HpcInfo :: Int -> Int -> HpcInfo

- HscTypes: HsBootFile :: HscSource

- HscTypes: HsParsedModule :: Located HsModule -> [FilePath] -> ApiAnns -> HsParsedModule

- HscTypes: HsSrcFile :: HscSource

- HscTypes: Hsc :: (HscEnv -> WarningMessages -> IO (a, WarningMessages)) -> Hsc a

- HscTypes: HscEnv :: DynFlags -> [Target] -> ModuleGraph -> InteractiveContext -> HomePackageTable -> {-# UNPACK #-} !IORef ExternalPackageState -> {-# UNPACK #-} !IORef NameCache -> {-# UNPACK #-} !IORef FinderCache -> Maybe (Module, IORef TypeEnv) -> MVar (Maybe IServ) -> DynLinker -> HscEnv

- HscTypes: HscNotGeneratingCode :: ModIface -> ModDetails -> HscStatus

- HscTypes: HscRecomp :: CgGuts -> !ModLocation -> !ModDetails -> !PartialModIface -> !Maybe Fingerprint -> !DynFlags -> HscStatus

- HscTypes: HscUpToDate :: ModIface -> ModDetails -> HscStatus

- HscTypes: HscUpdateBoot :: ModIface -> ModDetails -> HscStatus

- HscTypes: HscUpdateSig :: ModIface -> ModDetails -> HscStatus

- HscTypes: HsigFile :: HscSource

- HscTypes: IIDecl :: ImportDecl GhcPs -> InteractiveImport

- HscTypes: IIModule :: ModuleName -> InteractiveImport

- HscTypes: IServ :: Pipe -> ProcessHandle -> IORef (UniqFM (Ptr ())) -> [HValueRef] -> IServ

- HscTypes: ImportedBySystem :: ImportedBy

- HscTypes: ImportedByUser :: ImportedModsVal -> ImportedBy

- HscTypes: ImportedModsVal :: ModuleName -> SrcSpan -> IsSafeImport -> Bool -> !GlobalRdrEnv -> Bool -> ImportedModsVal

- HscTypes: InstalledFound :: ModLocation -> InstalledModule -> InstalledFindResult

- HscTypes: InstalledNoPackage :: InstalledUnitId -> InstalledFindResult

- HscTypes: InstalledNotFound :: [FilePath] -> Maybe InstalledUnitId -> InstalledFindResult

- HscTypes: InteractiveContext :: DynFlags -> Int -> [InteractiveImport] -> [TyThing] -> GlobalRdrEnv -> ([ClsInst], [FamInst]) -> FixityEnv -> Maybe [Type] -> [Resume] -> Name -> Name -> Maybe FilePath -> InteractiveContext

- HscTypes: LM :: UTCTime -> Module -> [Unlinked] -> Linkable

- HscTypes: LangAsm :: ForeignSrcLang

- HscTypes: LangC :: ForeignSrcLang

- HscTypes: LangCxx :: ForeignSrcLang

- HscTypes: LangObjc :: ForeignSrcLang

- HscTypes: LangObjcxx :: ForeignSrcLang

- HscTypes: MetaAW :: (Serialized -> MetaResult) -> MetaRequest

- HscTypes: MetaD :: ([LHsDecl GhcPs] -> MetaResult) -> MetaRequest

- HscTypes: MetaE :: (LHsExpr GhcPs -> MetaResult) -> MetaRequest

- HscTypes: MetaP :: (LPat GhcPs -> MetaResult) -> MetaRequest

- HscTypes: MetaT :: (LHsType GhcPs -> MetaResult) -> MetaRequest

- HscTypes: ModBreaks :: ForeignRef BreakArray -> !Array BreakIndex SrcSpan -> !Array BreakIndex [OccName] -> !Array BreakIndex [String] -> !Array BreakIndex (RemotePtr CostCentre) -> IntMap CgBreakInfo -> ModBreaks

- HscTypes: ModDetails :: [AvailInfo] -> !TypeEnv -> ![ClsInst] -> ![FamInst] -> ![CoreRule] -> ![Annotation] -> [CompleteMatch] -> ModDetails

- HscTypes: ModGuts :: !Module -> HscSource -> SrcSpan -> ![AvailInfo] -> !Dependencies -> ![Usage] -> !Bool -> !GlobalRdrEnv -> !FixityEnv -> ![TyCon] -> ![ClsInst] -> ![FamInst] -> ![PatSyn] -> ![CoreRule] -> !CoreProgram -> !ForeignStubs -> ![(ForeignSrcLang, FilePath)] -> !Warnings -> [Annotation] -> [CompleteMatch] -> !HpcInfo -> !Maybe ModBreaks -> InstEnv -> FamInstEnv -> SafeHaskellMode -> Bool -> !Maybe HsDocString -> !DeclDocMap -> !ArgDocMap -> ModGuts

- HscTypes: ModIface :: !Module -> !Maybe Module -> !HscSource -> Dependencies -> [Usage] -> ![IfaceExport] -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [IfaceDeclExts phase] -> !Maybe GlobalRdrEnv -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> [IfaceCompleteMatch] -> Maybe HsDocString -> DeclDocMap -> ArgDocMap -> !IfaceBackendExts phase -> ModIface_

- HscTypes: ModIfaceBackend :: !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !Fingerprint -> !Fingerprint -> !OccName -> Maybe WarningTxt -> !OccName -> Maybe Fixity -> !OccName -> Maybe (OccName, Fingerprint) -> ModIfaceBackend

- HscTypes: ModSummary :: Module -> HscSource -> ModLocation -> UTCTime -> Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime -> [(Maybe FastString, Located ModuleName)] -> [(Maybe FastString, Located ModuleName)] -> Maybe HsParsedModule -> FilePath -> DynFlags -> Maybe StringBuffer -> ModSummary

- HscTypes: NoHpcInfo :: AnyHpcUsage -> HpcInfo

- HscTypes: NoPackage :: UnitId -> FindResult

- HscTypes: NoStubs :: ForeignStubs

- HscTypes: NoWarnings :: Warnings

- HscTypes: NotFound :: [FilePath] -> Maybe UnitId -> [UnitId] -> [UnitId] -> [(UnitId, UnusablePackageReason)] -> [ModuleSuggestion] -> FindResult

- HscTypes: RawObject :: ForeignSrcLang

- HscTypes: SourceModified :: SourceModified

- HscTypes: SourceUnmodified :: SourceModified

- HscTypes: SourceUnmodifiedAndStable :: SourceModified

- HscTypes: SptEntry :: Id -> Fingerprint -> SptEntry

- HscTypes: Target :: TargetId -> Bool -> Maybe (InputFileBuffer, UTCTime) -> Target

- HscTypes: TargetFile :: FilePath -> Maybe Phase -> TargetId

- HscTypes: TargetModule :: ModuleName -> TargetId

- HscTypes: UsageFile :: FilePath -> Fingerprint -> Usage

- HscTypes: UsageHomeModule :: ModuleName -> Fingerprint -> [(OccName, Fingerprint)] -> Maybe Fingerprint -> IsSafeImport -> Usage

- HscTypes: UsageMergedRequirement :: Module -> Fingerprint -> Usage

- HscTypes: UsagePackageModule :: Module -> Fingerprint -> IsSafeImport -> Usage

- HscTypes: WarnAll :: WarningTxt -> Warnings

- HscTypes: WarnSome :: [(OccName, WarningTxt)] -> Warnings

- HscTypes: WarningTxt :: Located SourceText -> [Located StringLiteral] -> WarningTxt

- HscTypes: [cg_binds] :: CgGuts -> CoreProgram

- HscTypes: [cg_dep_pkgs] :: CgGuts -> ![InstalledUnitId]

- HscTypes: [cg_foreign] :: CgGuts -> !ForeignStubs

- HscTypes: [cg_foreign_files] :: CgGuts -> ![(ForeignSrcLang, FilePath)]

- HscTypes: [cg_hpc_info] :: CgGuts -> !HpcInfo

- HscTypes: [cg_modBreaks] :: CgGuts -> !Maybe ModBreaks

- HscTypes: [cg_module] :: CgGuts -> !Module

- HscTypes: [cg_spt_entries] :: CgGuts -> [SptEntry]

- HscTypes: [cg_tycons] :: CgGuts -> [TyCon]

- HscTypes: [completeMatchConLikes] :: CompleteMatch -> [Name]

- HscTypes: [completeMatchTyCon] :: CompleteMatch -> Name

- HscTypes: [dep_finsts] :: Dependencies -> [Module]

- HscTypes: [dep_mods] :: Dependencies -> [(ModuleName, IsBootInterface)]

- HscTypes: [dep_orphs] :: Dependencies -> [Module]

- HscTypes: [dep_pkgs] :: Dependencies -> [(InstalledUnitId, Bool)]

- HscTypes: [dep_plgins] :: Dependencies -> [ModuleName]

- HscTypes: [eps_PIT] :: ExternalPackageState -> !PackageIfaceTable

- HscTypes: [eps_PTE] :: ExternalPackageState -> !PackageTypeEnv

- HscTypes: [eps_ann_env] :: ExternalPackageState -> !PackageAnnEnv

- HscTypes: [eps_complete_matches] :: ExternalPackageState -> !PackageCompleteMatchMap

- HscTypes: [eps_fam_inst_env] :: ExternalPackageState -> !PackageFamInstEnv

- HscTypes: [eps_free_holes] :: ExternalPackageState -> InstalledModuleEnv (UniqDSet ModuleName)

- HscTypes: [eps_inst_env] :: ExternalPackageState -> !PackageInstEnv

- HscTypes: [eps_is_boot] :: ExternalPackageState -> !ModuleNameEnv (ModuleName, IsBootInterface)

- HscTypes: [eps_mod_fam_inst_env] :: ExternalPackageState -> !ModuleEnv FamInstEnv

- HscTypes: [eps_rule_base] :: ExternalPackageState -> !PackageRuleBase

- HscTypes: [eps_stats] :: ExternalPackageState -> !EpsStats

- HscTypes: [fr_mods_hidden] :: FindResult -> [UnitId]

- HscTypes: [fr_paths] :: FindResult -> [FilePath]

- HscTypes: [fr_pkg] :: FindResult -> Maybe UnitId

- HscTypes: [fr_pkgs_hidden] :: FindResult -> [UnitId]

- HscTypes: [fr_suggestions] :: FindResult -> [ModuleSuggestion]

- HscTypes: [fr_unusables] :: FindResult -> [(UnitId, UnusablePackageReason)]

- HscTypes: [hm_details] :: HomeModInfo -> !ModDetails

- HscTypes: [hm_iface] :: HomeModInfo -> !ModIface

- HscTypes: [hm_linkable] :: HomeModInfo -> !Maybe Linkable

- HscTypes: [hpcInfoHash] :: HpcInfo -> Int

- HscTypes: [hpcInfoTickCount] :: HpcInfo -> Int

- HscTypes: [hpcUsed] :: HpcInfo -> AnyHpcUsage

- HscTypes: [hpm_annotations] :: HsParsedModule -> ApiAnns

- HscTypes: [hpm_module] :: HsParsedModule -> Located HsModule

- HscTypes: [hpm_src_files] :: HsParsedModule -> [FilePath]

- HscTypes: [hsc_EPS] :: HscEnv -> {-# UNPACK #-} !IORef ExternalPackageState

- HscTypes: [hsc_FC] :: HscEnv -> {-# UNPACK #-} !IORef FinderCache

- HscTypes: [hsc_HPT] :: HscEnv -> HomePackageTable

- HscTypes: [hsc_IC] :: HscEnv -> InteractiveContext

- HscTypes: [hsc_NC] :: HscEnv -> {-# UNPACK #-} !IORef NameCache

- HscTypes: [hsc_dflags] :: HscEnv -> DynFlags

- HscTypes: [hsc_dynLinker] :: HscEnv -> DynLinker

- HscTypes: [hsc_iserv] :: HscEnv -> MVar (Maybe IServ)

- HscTypes: [hsc_mod_graph] :: HscEnv -> ModuleGraph

- HscTypes: [hsc_targets] :: HscEnv -> [Target]

- HscTypes: [hsc_type_env_var] :: HscEnv -> Maybe (Module, IORef TypeEnv)

- HscTypes: [hscs_guts] :: HscStatus -> CgGuts

- HscTypes: [hscs_iface_dflags] :: HscStatus -> !DynFlags

- HscTypes: [hscs_mod_details] :: HscStatus -> !ModDetails

- HscTypes: [hscs_mod_location] :: HscStatus -> !ModLocation

- HscTypes: [hscs_old_iface_hash] :: HscStatus -> !Maybe Fingerprint

- HscTypes: [hscs_partial_iface] :: HscStatus -> !PartialModIface

- HscTypes: [ic_cwd] :: InteractiveContext -> Maybe FilePath

- HscTypes: [ic_default] :: InteractiveContext -> Maybe [Type]

- HscTypes: [ic_dflags] :: InteractiveContext -> DynFlags

- HscTypes: [ic_fix_env] :: InteractiveContext -> FixityEnv

- HscTypes: [ic_imports] :: InteractiveContext -> [InteractiveImport]

- HscTypes: [ic_instances] :: InteractiveContext -> ([ClsInst], [FamInst])

- HscTypes: [ic_int_print] :: InteractiveContext -> Name

- HscTypes: [ic_mod_index] :: InteractiveContext -> Int

- HscTypes: [ic_monad] :: InteractiveContext -> Name

- HscTypes: [ic_resume] :: InteractiveContext -> [Resume]

- HscTypes: [ic_rn_gbl_env] :: InteractiveContext -> GlobalRdrEnv

- HscTypes: [ic_tythings] :: InteractiveContext -> [TyThing]

- HscTypes: [imv_all_exports] :: ImportedModsVal -> !GlobalRdrEnv

- HscTypes: [imv_is_hiding] :: ImportedModsVal -> Bool

- HscTypes: [imv_is_safe] :: ImportedModsVal -> IsSafeImport

- HscTypes: [imv_name] :: ImportedModsVal -> ModuleName

- HscTypes: [imv_qualified] :: ImportedModsVal -> Bool

- HscTypes: [imv_span] :: ImportedModsVal -> SrcSpan

- HscTypes: [iservLookupSymbolCache] :: IServ -> IORef (UniqFM (Ptr ()))

- HscTypes: [iservPendingFrees] :: IServ -> [HValueRef]

- HscTypes: [iservPipe] :: IServ -> Pipe

- HscTypes: [iservProcess] :: IServ -> ProcessHandle

- HscTypes: [linkableModule] :: Linkable -> Module

- HscTypes: [linkableTime] :: Linkable -> UTCTime

- HscTypes: [linkableUnlinked] :: Linkable -> [Unlinked]

- HscTypes: [md_anns] :: ModDetails -> ![Annotation]

- HscTypes: [md_complete_sigs] :: ModDetails -> [CompleteMatch]

- HscTypes: [md_exports] :: ModDetails -> [AvailInfo]

- HscTypes: [md_fam_insts] :: ModDetails -> ![FamInst]

- HscTypes: [md_insts] :: ModDetails -> ![ClsInst]

- HscTypes: [md_rules] :: ModDetails -> ![CoreRule]

- HscTypes: [md_types] :: ModDetails -> !TypeEnv

- HscTypes: [mg_anns] :: ModGuts -> [Annotation]

- HscTypes: [mg_arg_docs] :: ModGuts -> !ArgDocMap

- HscTypes: [mg_binds] :: ModGuts -> !CoreProgram

- HscTypes: [mg_complete_sigs] :: ModGuts -> [CompleteMatch]

- HscTypes: [mg_decl_docs] :: ModGuts -> !DeclDocMap

- HscTypes: [mg_deps] :: ModGuts -> !Dependencies

- HscTypes: [mg_doc_hdr] :: ModGuts -> !Maybe HsDocString

- HscTypes: [mg_exports] :: ModGuts -> ![AvailInfo]

- HscTypes: [mg_fam_inst_env] :: ModGuts -> FamInstEnv

- HscTypes: [mg_fam_insts] :: ModGuts -> ![FamInst]

- HscTypes: [mg_fix_env] :: ModGuts -> !FixityEnv

- HscTypes: [mg_foreign] :: ModGuts -> !ForeignStubs

- HscTypes: [mg_foreign_files] :: ModGuts -> ![(ForeignSrcLang, FilePath)]

- HscTypes: [mg_hpc_info] :: ModGuts -> !HpcInfo

- HscTypes: [mg_hsc_src] :: ModGuts -> HscSource

- HscTypes: [mg_inst_env] :: ModGuts -> InstEnv

- HscTypes: [mg_insts] :: ModGuts -> ![ClsInst]

- HscTypes: [mg_loc] :: ModGuts -> SrcSpan

- HscTypes: [mg_modBreaks] :: ModGuts -> !Maybe ModBreaks

- HscTypes: [mg_module] :: ModGuts -> !Module

- HscTypes: [mg_patsyns] :: ModGuts -> ![PatSyn]

- HscTypes: [mg_rdr_env] :: ModGuts -> !GlobalRdrEnv

- HscTypes: [mg_rules] :: ModGuts -> ![CoreRule]

- HscTypes: [mg_safe_haskell] :: ModGuts -> SafeHaskellMode

- HscTypes: [mg_tcs] :: ModGuts -> ![TyCon]

- HscTypes: [mg_trust_pkg] :: ModGuts -> Bool

- HscTypes: [mg_usages] :: ModGuts -> ![Usage]

- HscTypes: [mg_used_th] :: ModGuts -> !Bool

- HscTypes: [mg_warns] :: ModGuts -> !Warnings

- HscTypes: [mi_anns] :: ModIface_ -> [IfaceAnnotation]

- HscTypes: [mi_arg_docs] :: ModIface_ -> ArgDocMap

- HscTypes: [mi_complete_sigs] :: ModIface_ -> [IfaceCompleteMatch]

- HscTypes: [mi_decl_docs] :: ModIface_ -> DeclDocMap

- HscTypes: [mi_decls] :: ModIface_ -> [IfaceDeclExts phase]

- HscTypes: [mi_deps] :: ModIface_ -> Dependencies

- HscTypes: [mi_doc_hdr] :: ModIface_ -> Maybe HsDocString

- HscTypes: [mi_exp_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_exports] :: ModIface_ -> ![IfaceExport]

- HscTypes: [mi_fam_insts] :: ModIface_ -> [IfaceFamInst]

- HscTypes: [mi_final_exts] :: ModIface_ -> !IfaceBackendExts phase

- HscTypes: [mi_finsts] :: ModIfaceBackend -> !WhetherHasFamInst

- HscTypes: [mi_fix_fn] :: ModIfaceBackend -> !OccName -> Maybe Fixity

- HscTypes: [mi_fixities] :: ModIface_ -> [(OccName, Fixity)]

- HscTypes: [mi_flag_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_globals] :: ModIface_ -> !Maybe GlobalRdrEnv

- HscTypes: [mi_hash_fn] :: ModIfaceBackend -> !OccName -> Maybe (OccName, Fingerprint)

- HscTypes: [mi_hpc] :: ModIface_ -> !AnyHpcUsage

- HscTypes: [mi_hpc_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_hsc_src] :: ModIface_ -> !HscSource

- HscTypes: [mi_iface_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_insts] :: ModIface_ -> [IfaceClsInst]

- HscTypes: [mi_mod_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_module] :: ModIface_ -> !Module

- HscTypes: [mi_opt_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_orphan] :: ModIfaceBackend -> !WhetherHasOrphans

- HscTypes: [mi_orphan_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_plugin_hash] :: ModIfaceBackend -> !Fingerprint

- HscTypes: [mi_rules] :: ModIface_ -> [IfaceRule]

- HscTypes: [mi_sig_of] :: ModIface_ -> !Maybe Module

- HscTypes: [mi_trust] :: ModIface_ -> !IfaceTrustInfo

- HscTypes: [mi_trust_pkg] :: ModIface_ -> !Bool

- HscTypes: [mi_usages] :: ModIface_ -> [Usage]

- HscTypes: [mi_used_th] :: ModIface_ -> !Bool

- HscTypes: [mi_warn_fn] :: ModIfaceBackend -> !OccName -> Maybe WarningTxt

- HscTypes: [mi_warns] :: ModIface_ -> Warnings

- HscTypes: [modBreaks_breakInfo] :: ModBreaks -> IntMap CgBreakInfo

- HscTypes: [modBreaks_ccs] :: ModBreaks -> !Array BreakIndex (RemotePtr CostCentre)

- HscTypes: [modBreaks_decls] :: ModBreaks -> !Array BreakIndex [String]

- HscTypes: [modBreaks_flags] :: ModBreaks -> ForeignRef BreakArray

- HscTypes: [modBreaks_locs] :: ModBreaks -> !Array BreakIndex SrcSpan

- HscTypes: [modBreaks_vars] :: ModBreaks -> !Array BreakIndex [OccName]

- HscTypes: [ms_hie_date] :: ModSummary -> Maybe UTCTime

- HscTypes: [ms_hs_date] :: ModSummary -> UTCTime

- HscTypes: [ms_hsc_src] :: ModSummary -> HscSource

- HscTypes: [ms_hspp_buf] :: ModSummary -> Maybe StringBuffer

- HscTypes: [ms_hspp_file] :: ModSummary -> FilePath

- HscTypes: [ms_hspp_opts] :: ModSummary -> DynFlags

- HscTypes: [ms_iface_date] :: ModSummary -> Maybe UTCTime

- HscTypes: [ms_location] :: ModSummary -> ModLocation

- HscTypes: [ms_mod] :: ModSummary -> Module

- HscTypes: [ms_obj_date] :: ModSummary -> Maybe UTCTime

- HscTypes: [ms_parsed_mod] :: ModSummary -> Maybe HsParsedModule

- HscTypes: [ms_srcimps] :: ModSummary -> [(Maybe FastString, Located ModuleName)]

- HscTypes: [ms_textual_imps] :: ModSummary -> [(Maybe FastString, Located ModuleName)]

- HscTypes: [n_ifaces_in, n_decls_in, n_decls_out, n_rules_in, n_rules_out, n_insts_in, n_insts_out] :: EpsStats -> !Int

- HscTypes: [targetAllowObjCode] :: Target -> Bool

- HscTypes: [targetContents] :: Target -> Maybe (InputFileBuffer, UTCTime)

- HscTypes: [targetId] :: Target -> TargetId

- HscTypes: [usg_entities] :: Usage -> [(OccName, Fingerprint)]

- HscTypes: [usg_exports] :: Usage -> Maybe Fingerprint

- HscTypes: [usg_file_hash] :: Usage -> Fingerprint

- HscTypes: [usg_file_path] :: Usage -> FilePath

- HscTypes: [usg_mod] :: Usage -> Module

- HscTypes: [usg_mod_hash] :: Usage -> Fingerprint

- HscTypes: [usg_mod_name] :: Usage -> ModuleName

- HscTypes: [usg_safe] :: Usage -> IsSafeImport

- HscTypes: addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats

- HscTypes: addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable

- HscTypes: addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable

- HscTypes: allHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> Bool

- HscTypes: appendStubC :: ForeignStubs -> SDoc -> ForeignStubs

- HscTypes: byteCodeOfObject :: Unlinked -> CompiledByteCode

- HscTypes: class Monad m => MonadThings m

- HscTypes: data CgGuts

- HscTypes: data CompiledByteCode

- HscTypes: data CompleteMatch

- HscTypes: data Dependencies

- HscTypes: data EpsStats

- HscTypes: data ExternalPackageState

- HscTypes: data FindResult

- HscTypes: data FixItem

- HscTypes: data ForeignSrcLang

- HscTypes: data ForeignStubs

- HscTypes: data GhcApiError

- HscTypes: data HomeModInfo

- HscTypes: data HpcInfo

- HscTypes: data HsParsedModule

- HscTypes: data HscEnv

- HscTypes: data HscSource

- HscTypes: data HscStatus

- HscTypes: data IServ

- HscTypes: data IfaceTrustInfo

- HscTypes: data ImportedBy

- HscTypes: data ImportedModsVal

- HscTypes: data InstalledFindResult

- HscTypes: data InteractiveContext

- HscTypes: data InteractiveImport

- HscTypes: data Linkable

- HscTypes: data MetaRequest

- HscTypes: data MetaResult

- HscTypes: data ModBreaks

- HscTypes: data ModDetails

- HscTypes: data ModGuts

- HscTypes: data ModIfaceBackend

- HscTypes: data ModIface_ (phase :: ModIfacePhase)

- HscTypes: data ModSummary

- HscTypes: data ModuleGraph

- HscTypes: data SourceError

- HscTypes: data SourceModified

- HscTypes: data SptEntry

- HscTypes: data Target

- HscTypes: data TargetId

- HscTypes: data TyThing

- HscTypes: data Unlinked

- HscTypes: data Usage

- HscTypes: data WarningTxt

- HscTypes: data Warnings

- HscTypes: delFromHpt :: HomePackageTable -> ModuleName -> HomePackageTable

- HscTypes: eltsHpt :: HomePackageTable -> [HomeModInfo]

- HscTypes: emptyFixityEnv :: FixityEnv

- HscTypes: emptyFullModIface :: Module -> ModIface

- HscTypes: emptyHomePackageTable :: HomePackageTable

- HscTypes: emptyHpcInfo :: AnyHpcUsage -> HpcInfo

- HscTypes: emptyIfaceWarnCache :: OccName -> Maybe WarningTxt

- HscTypes: emptyInteractiveContext :: DynFlags -> InteractiveContext

- HscTypes: emptyMG :: ModuleGraph

- HscTypes: emptyModBreaks :: ModBreaks

- HscTypes: emptyModDetails :: ModDetails

- HscTypes: emptyPackageIfaceTable :: PackageIfaceTable

- HscTypes: emptyPartialModIface :: Module -> PartialModIface

- HscTypes: emptyTypeEnv :: TypeEnv

- HscTypes: extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap

- HscTypes: extendInteractiveContext :: InteractiveContext -> [TyThing] -> [ClsInst] -> [FamInst] -> Maybe [Type] -> FixityEnv -> InteractiveContext

- HscTypes: extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext

- HscTypes: extendMG :: ModuleGraph -> ModSummary -> ModuleGraph

- HscTypes: extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv

- HscTypes: extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv

- HscTypes: extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv

- HscTypes: filterHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> HomePackageTable

- HscTypes: getSafeMode :: IfaceTrustInfo -> SafeHaskellMode

- HscTypes: handleFlagWarnings :: DynFlags -> [Warn] -> IO ()

- HscTypes: handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a

- HscTypes: home_imps :: [(Maybe FastString, Located ModuleName)] -> [Located ModuleName]

- HscTypes: hptCompleteSigs :: HscEnv -> [CompleteMatch]

- HscTypes: hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])

- HscTypes: hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]

- HscTypes: hscEPS :: HscEnv -> IO ExternalPackageState

- HscTypes: hscSourceString :: HscSource -> String

- HscTypes: icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv

- HscTypes: icInScopeTTs :: InteractiveContext -> [TyThing]

- HscTypes: icInteractiveModule :: InteractiveContext -> Module

- HscTypes: icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified

- HscTypes: implicitClassThings :: Class -> [TyThing]

- HscTypes: implicitTyConThings :: TyCon -> [TyThing]

- HscTypes: implicitTyThings :: TyThing -> [TyThing]

- HscTypes: importedByUser :: [ImportedBy] -> [ImportedModsVal]

- HscTypes: instance (Control.DeepSeq.NFData (HscTypes.IfaceBackendExts phase), Control.DeepSeq.NFData (HscTypes.IfaceDeclExts phase)) => Control.DeepSeq.NFData (HscTypes.ModIface_ phase)

- HscTypes: instance Binary.Binary HscTypes.Dependencies

- HscTypes: instance Binary.Binary HscTypes.IfaceTrustInfo

- HscTypes: instance Binary.Binary HscTypes.ModIface

- HscTypes: instance Binary.Binary HscTypes.Usage

- HscTypes: instance Binary.Binary HscTypes.Warnings

- HscTypes: instance Control.Monad.IO.Class.MonadIO HscTypes.Hsc

- HscTypes: instance DynFlags.HasDynFlags HscTypes.Hsc

- HscTypes: instance GHC.Base.Applicative HscTypes.Hsc

- HscTypes: instance GHC.Base.Functor HscTypes.Hsc

- HscTypes: instance GHC.Base.Monad HscTypes.Hsc

- HscTypes: instance GHC.Classes.Eq HscTypes.Dependencies

- HscTypes: instance GHC.Classes.Eq HscTypes.TargetId

- HscTypes: instance GHC.Classes.Eq HscTypes.Usage

- HscTypes: instance GHC.Classes.Eq HscTypes.Warnings

- HscTypes: instance GHC.Exception.Type.Exception HscTypes.GhcApiError

- HscTypes: instance GHC.Exception.Type.Exception HscTypes.SourceError

- HscTypes: instance GHC.Show.Show HscTypes.GhcApiError

- HscTypes: instance GHC.Show.Show HscTypes.SourceError

- HscTypes: instance HscTypes.MonadThings m => HscTypes.MonadThings (Control.Monad.Trans.Reader.ReaderT s m)

- HscTypes: instance Outputable.Outputable HscTypes.CompleteMatch

- HscTypes: instance Outputable.Outputable HscTypes.FixItem

- HscTypes: instance Outputable.Outputable HscTypes.IfaceTrustInfo

- HscTypes: instance Outputable.Outputable HscTypes.InteractiveImport

- HscTypes: instance Outputable.Outputable HscTypes.ModSummary

- HscTypes: instance Outputable.Outputable HscTypes.Target

- HscTypes: instance Outputable.Outputable HscTypes.TargetId

- HscTypes: isBootSummary :: ModSummary -> Bool

- HscTypes: isHpcUsed :: HpcInfo -> AnyHpcUsage

- HscTypes: isHsBootOrSig :: HscSource -> Bool

- HscTypes: isHsigFile :: HscSource -> Bool

- HscTypes: isImplicitTyThing :: TyThing -> Bool

- HscTypes: isInterpretable :: Unlinked -> Bool

- HscTypes: isObject :: Unlinked -> Bool

- HscTypes: isObjectLinkable :: Linkable -> Bool

- HscTypes: isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool

- HscTypes: linkableObjs :: Linkable -> [FilePath]

- HscTypes: listToHpt :: [(ModuleName, HomeModInfo)] -> HomePackageTable

- HscTypes: lookupDataCon :: MonadThings m => Name -> m DataCon

- HscTypes: lookupFixity :: FixityEnv -> Name -> Fixity

- HscTypes: lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo

- HscTypes: lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo

- HscTypes: lookupHptDirectly :: HomePackageTable -> Unique -> Maybe HomeModInfo

- HscTypes: lookupId :: MonadThings m => Name -> m Id

- HscTypes: lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface

- HscTypes: lookupThing :: MonadThings m => Name -> m TyThing

- HscTypes: lookupTyCon :: MonadThings m => Name -> m TyCon

- HscTypes: lookupType :: DynFlags -> HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing

- HscTypes: lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing

- HscTypes: lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)

- HscTypes: mapHpt :: (HomeModInfo -> HomeModInfo) -> HomePackageTable -> HomePackageTable

- HscTypes: mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph

- HscTypes: metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized

- HscTypes: metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]

- HscTypes: metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)

- HscTypes: metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)

- HscTypes: metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)

- HscTypes: mgBootModules :: ModuleGraph -> ModuleSet

- HscTypes: mgElemModule :: ModuleGraph -> Module -> Bool

- HscTypes: mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary

- HscTypes: mgModSummaries :: ModuleGraph -> [ModSummary]

- HscTypes: mi_boot :: ModIface -> Bool

- HscTypes: mi_fix :: ModIface -> OccName -> Fixity

- HscTypes: mi_free_holes :: ModIface -> UniqDSet ModuleName

- HscTypes: mi_semantic_module :: ModIface_ a -> Module

- HscTypes: mkApiErr :: DynFlags -> SDoc -> GhcApiError

- HscTypes: mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap

- HscTypes: mkHsSOName :: Platform -> FilePath -> FilePath

- HscTypes: mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity

- HscTypes: mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> OccName -> Maybe (OccName, Fingerprint)

- HscTypes: mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt

- HscTypes: mkInteractiveHscEnv :: HscEnv -> HscEnv

- HscTypes: mkModuleGraph :: [ModSummary] -> ModuleGraph

- HscTypes: mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified

- HscTypes: mkQualModule :: DynFlags -> QueryQualifyModule

- HscTypes: mkQualPackage :: DynFlags -> QueryQualifyPackage

- HscTypes: mkSOName :: Platform -> FilePath -> FilePath

- HscTypes: mkSrcErr :: ErrorMessages -> SourceError

- HscTypes: mkTypeEnv :: [TyThing] -> TypeEnv

- HscTypes: mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv

- HscTypes: msHiFilePath :: ModSummary -> FilePath

- HscTypes: msHsFilePath :: ModSummary -> FilePath

- HscTypes: msObjFilePath :: ModSummary -> FilePath

- HscTypes: ms_home_allimps :: ModSummary -> [ModuleName]

- HscTypes: ms_home_imps :: ModSummary -> [Located ModuleName]

- HscTypes: ms_home_srcimps :: ModSummary -> [Located ModuleName]

- HscTypes: ms_imps :: ModSummary -> [(Maybe FastString, Located ModuleName)]

- HscTypes: ms_installed_mod :: ModSummary -> InstalledModule

- HscTypes: ms_mod_name :: ModSummary -> ModuleName

- HscTypes: nameOfObject :: Unlinked -> FilePath

- HscTypes: needsTemplateHaskellOrQQ :: ModuleGraph -> Bool

- HscTypes: newtype Hsc a

- HscTypes: noDependencies :: Dependencies

- HscTypes: noIfaceTrustInfo :: IfaceTrustInfo

- HscTypes: numToTrustInfo :: Word8 -> IfaceTrustInfo

- HscTypes: phaseForeignLanguage :: Phase -> Maybe ForeignSrcLang

- HscTypes: pkgQual :: DynFlags -> PrintUnqualified

- HscTypes: plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv

- HscTypes: plusWarns :: Warnings -> Warnings -> Warnings

- HscTypes: pprHPT :: HomePackageTable -> SDoc

- HscTypes: pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc

- HscTypes: pprTarget :: Target -> SDoc

- HscTypes: pprTargetId :: TargetId -> SDoc

- HscTypes: prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv

- HscTypes: printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()

- HscTypes: renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName

- HscTypes: runHsc :: HscEnv -> Hsc a -> IO a

- HscTypes: runInteractiveHsc :: HscEnv -> Hsc a -> IO a

- HscTypes: setInteractivePackage :: HscEnv -> HscEnv

- HscTypes: setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext

- HscTypes: setSafeMode :: SafeHaskellMode -> IfaceTrustInfo

- HscTypes: showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String

- HscTypes: soExt :: Platform -> FilePath

- HscTypes: srcErrorMessages :: SourceError -> ErrorMessages

- HscTypes: substInteractiveContext :: InteractiveContext -> TCvSubst -> InteractiveContext

- HscTypes: throwErrors :: MonadIO io => ErrorMessages -> io a

- HscTypes: throwOneError :: MonadIO io => ErrMsg -> io a

- HscTypes: trustInfoToNum :: IfaceTrustInfo -> Word8

- HscTypes: tyThingAvailInfo :: TyThing -> [AvailInfo]

- HscTypes: tyThingCoAxiom :: TyThing -> CoAxiom Branched

- HscTypes: tyThingConLike :: TyThing -> ConLike

- HscTypes: tyThingDataCon :: TyThing -> DataCon

- HscTypes: tyThingId :: TyThing -> Id

- HscTypes: tyThingParent_maybe :: TyThing -> Maybe TyThing

- HscTypes: tyThingTyCon :: TyThing -> TyCon

- HscTypes: tyThingsTyCoVars :: [TyThing] -> TyCoVarSet

- HscTypes: type AnyHpcUsage = Bool

- HscTypes: type CompleteMatchMap = UniqFM [CompleteMatch]

- HscTypes: type FinderCache = InstalledModuleEnv InstalledFindResult

- HscTypes: type FixityEnv = NameEnv FixItem

- HscTypes: type HomePackageTable = DModuleNameEnv HomeModInfo

- HscTypes: type IfaceExport = AvailInfo

- HscTypes: type ImportedMods = ModuleEnv [ImportedBy]

- HscTypes: type InputFileBuffer = StringBuffer

- HscTypes: type IsBootInterface = Bool

- HscTypes: type IsSafeImport = Bool

- HscTypes: type MetaHook f = MetaRequest -> LHsExpr GhcTc -> f MetaResult

- HscTypes: type ModIface = ModIface_ 'ModIfaceFinal

- HscTypes: type PackageCompleteMatchMap = CompleteMatchMap

- HscTypes: type PackageFamInstEnv = FamInstEnv

- HscTypes: type PackageIfaceTable = ModuleEnv ModIface

- HscTypes: type PackageInstEnv = InstEnv

- HscTypes: type PackageRuleBase = RuleBase

- HscTypes: type PackageTypeEnv = TypeEnv

- HscTypes: type PartialModIface = ModIface_ 'ModIfaceCore

- HscTypes: type TypeEnv = NameEnv TyThing

- HscTypes: type WhetherHasOrphans = Bool

- HscTypes: typeEnvClasses :: TypeEnv -> [Class]

- HscTypes: typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]

- HscTypes: typeEnvDataCons :: TypeEnv -> [DataCon]

- HscTypes: typeEnvElts :: TypeEnv -> [TyThing]

- HscTypes: typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv

- HscTypes: typeEnvIds :: TypeEnv -> [Id]

- HscTypes: typeEnvPatSyns :: TypeEnv -> [PatSyn]

- HscTypes: typeEnvTyCons :: TypeEnv -> [TyCon]

- HscTypes: updNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c

- IOEnv: instance DynFlags.ContainsDynFlags env => DynFlags.HasDynFlags (IOEnv.IOEnv env)

- InteractiveEvalTypes: BreakInfo :: Module -> Int -> BreakInfo

- InteractiveEvalTypes: ExecBreak :: [Name] -> Maybe BreakInfo -> ExecResult

- InteractiveEvalTypes: ExecComplete :: Either SomeException [Name] -> Word64 -> ExecResult

- InteractiveEvalTypes: ExecOptions :: SingleStep -> String -> Int -> (ForeignHValue -> EvalExpr ForeignHValue) -> ExecOptions

- InteractiveEvalTypes: History :: ForeignHValue -> BreakInfo -> [String] -> History

- InteractiveEvalTypes: Resume :: String -> ForeignRef (ResumeContext [HValueRef]) -> ([TyThing], GlobalRdrEnv) -> [Id] -> ForeignHValue -> Maybe BreakInfo -> SrcSpan -> String -> RemotePtr CostCentreStack -> [History] -> Int -> Resume

- InteractiveEvalTypes: RunAndLogSteps :: SingleStep

- InteractiveEvalTypes: RunToCompletion :: SingleStep

- InteractiveEvalTypes: SingleStep :: SingleStep

- InteractiveEvalTypes: [breakInfo] :: ExecResult -> Maybe BreakInfo

- InteractiveEvalTypes: [breakInfo_module] :: BreakInfo -> Module

- InteractiveEvalTypes: [breakInfo_number] :: BreakInfo -> Int

- InteractiveEvalTypes: [breakNames] :: ExecResult -> [Name]

- InteractiveEvalTypes: [execAllocation] :: ExecResult -> Word64

- InteractiveEvalTypes: [execLineNumber] :: ExecOptions -> Int

- InteractiveEvalTypes: [execResult] :: ExecResult -> Either SomeException [Name]

- InteractiveEvalTypes: [execSingleStep] :: ExecOptions -> SingleStep

- InteractiveEvalTypes: [execSourceFile] :: ExecOptions -> String

- InteractiveEvalTypes: [execWrap] :: ExecOptions -> ForeignHValue -> EvalExpr ForeignHValue

- InteractiveEvalTypes: [historyApStack] :: History -> ForeignHValue

- InteractiveEvalTypes: [historyBreakInfo] :: History -> BreakInfo

- InteractiveEvalTypes: [historyEnclosingDecls] :: History -> [String]

- InteractiveEvalTypes: [resumeApStack] :: Resume -> ForeignHValue

- InteractiveEvalTypes: [resumeBindings] :: Resume -> ([TyThing], GlobalRdrEnv)

- InteractiveEvalTypes: [resumeBreakInfo] :: Resume -> Maybe BreakInfo

- InteractiveEvalTypes: [resumeCCS] :: Resume -> RemotePtr CostCentreStack

- InteractiveEvalTypes: [resumeContext] :: Resume -> ForeignRef (ResumeContext [HValueRef])

- InteractiveEvalTypes: [resumeDecl] :: Resume -> String

- InteractiveEvalTypes: [resumeFinalIds] :: Resume -> [Id]

- InteractiveEvalTypes: [resumeHistoryIx] :: Resume -> Int

- InteractiveEvalTypes: [resumeHistory] :: Resume -> [History]

- InteractiveEvalTypes: [resumeSpan] :: Resume -> SrcSpan

- InteractiveEvalTypes: [resumeStmt] :: Resume -> String

- InteractiveEvalTypes: data BreakInfo

- InteractiveEvalTypes: data ExecOptions

- InteractiveEvalTypes: data ExecResult

- InteractiveEvalTypes: data History

- InteractiveEvalTypes: data Resume

- InteractiveEvalTypes: data SingleStep

- InteractiveEvalTypes: isStep :: SingleStep -> Bool

- Lexer: instance Control.Monad.Fail.MonadFail Lexer.P

- LinkerTypes: BCOs :: CompiledByteCode -> [SptEntry] -> Unlinked

- LinkerTypes: DotA :: FilePath -> Unlinked

- LinkerTypes: DotDLL :: FilePath -> Unlinked

- LinkerTypes: DotO :: FilePath -> Unlinked

- LinkerTypes: DynLinker :: MVar (Maybe PersistentLinkerState) -> DynLinker

- LinkerTypes: LM :: UTCTime -> Module -> [Unlinked] -> Linkable

- LinkerTypes: PersistentLinkerState :: ClosureEnv -> !ItblEnv -> ![Linkable] -> ![Linkable] -> ![LinkerUnitId] -> ![(FilePath, String)] -> PersistentLinkerState

- LinkerTypes: SptEntry :: Id -> Fingerprint -> SptEntry

- LinkerTypes: [bcos_loaded] :: PersistentLinkerState -> ![Linkable]

- LinkerTypes: [closure_env] :: PersistentLinkerState -> ClosureEnv

- LinkerTypes: [dl_mpls] :: DynLinker -> MVar (Maybe PersistentLinkerState)

- LinkerTypes: [itbl_env] :: PersistentLinkerState -> !ItblEnv

- LinkerTypes: [linkableModule] :: Linkable -> Module

- LinkerTypes: [linkableTime] :: Linkable -> UTCTime

- LinkerTypes: [linkableUnlinked] :: Linkable -> [Unlinked]

- LinkerTypes: [objs_loaded] :: PersistentLinkerState -> ![Linkable]

- LinkerTypes: [pkgs_loaded] :: PersistentLinkerState -> ![LinkerUnitId]

- LinkerTypes: [temp_sos] :: PersistentLinkerState -> ![(FilePath, String)]

- LinkerTypes: data Linkable

- LinkerTypes: data PersistentLinkerState

- LinkerTypes: data SptEntry

- LinkerTypes: data Unlinked

- LinkerTypes: instance Outputable.Outputable LinkerTypes.Linkable

- LinkerTypes: instance Outputable.Outputable LinkerTypes.SptEntry

- LinkerTypes: instance Outputable.Outputable LinkerTypes.Unlinked

- LinkerTypes: newtype DynLinker

- LinkerTypes: type LinkerUnitId = InstalledUnitId

- MkCore: FloatCase :: CoreExpr -> Id -> AltCon -> [Var] -> FloatBind

- MkCore: FloatLet :: CoreBind -> FloatBind

- MkCore: aBSENT_ERROR_ID :: Id

- MkCore: aBSENT_SUM_FIELD_ERROR_ID :: Id

- MkCore: castBottomExpr :: CoreExpr -> Type -> CoreExpr

- MkCore: data FloatBind

- MkCore: errorIds :: [Id]

- MkCore: floatBindings :: FloatBind -> [Var]

- MkCore: infixl 4 `mkCoreApps`

- MkCore: instance Outputable.Outputable MkCore.FloatBind

- MkCore: mkAbsentErrorApp :: Type -> String -> CoreExpr

- MkCore: mkBigCoreTup :: [CoreExpr] -> CoreExpr

- MkCore: mkBigCoreTupTy :: [Type] -> Type

- MkCore: mkBigCoreVarTup :: [Id] -> CoreExpr

- MkCore: mkBigCoreVarTup1 :: [Id] -> CoreExpr

- MkCore: mkBigCoreVarTupTy :: [Id] -> Type

- MkCore: mkBuildExpr :: (MonadFail m, MonadThings m, MonadUnique m) => Type -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -> m CoreExpr

- MkCore: mkCharExpr :: Char -> CoreExpr

- MkCore: mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr

- MkCore: mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr

- MkCore: mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr

- MkCore: mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr

- MkCore: mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr

- MkCore: mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr

- MkCore: mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr

- MkCore: mkCoreTup :: [CoreExpr] -> CoreExpr

- MkCore: mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr

- MkCore: mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr

- MkCore: mkCoreVarTupTy :: [Id] -> Type

- MkCore: mkDoubleExpr :: Double -> CoreExpr

- MkCore: mkFloatExpr :: Float -> CoreExpr

- MkCore: mkFoldrExpr :: MonadThings m => Type -> Type -> CoreExpr -> CoreExpr -> CoreExpr -> m CoreExpr

- MkCore: mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr

- MkCore: mkImpossibleExpr :: Type -> CoreExpr

- MkCore: mkIntExpr :: DynFlags -> Integer -> CoreExpr

- MkCore: mkIntExprInt :: DynFlags -> Int -> CoreExpr

- MkCore: mkIntegerExpr :: MonadThings m => Integer -> m CoreExpr

- MkCore: mkJustExpr :: Type -> CoreExpr -> CoreExpr

- MkCore: mkListExpr :: Type -> [CoreExpr] -> CoreExpr

- MkCore: mkNaturalExpr :: MonadThings m => Integer -> m CoreExpr

- MkCore: mkNilExpr :: Type -> CoreExpr

- MkCore: mkNothingExpr :: Type -> CoreExpr

- MkCore: mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr

- MkCore: mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr

- MkCore: mkSmallTupleCase :: [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr

- MkCore: mkSmallTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

- MkCore: mkStringExpr :: MonadThings m => String -> m CoreExpr

- MkCore: mkStringExprFS :: MonadThings m => FastString -> m CoreExpr

- MkCore: mkStringExprFSWith :: Monad m => (Name -> m Id) -> FastString -> m CoreExpr

- MkCore: mkTupleCase :: UniqSupply -> [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr

- MkCore: mkTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

- MkCore: mkTupleSelector1 :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

- MkCore: mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr

- MkCore: mkWildEvBinder :: PredType -> EvVar

- MkCore: mkWildValBinder :: Type -> Id

- MkCore: mkWordExpr :: DynFlags -> Integer -> CoreExpr

- MkCore: mkWordExprWord :: DynFlags -> Word -> CoreExpr

- MkCore: nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id

- MkCore: nO_METHOD_BINDING_ERROR_ID :: Id

- MkCore: pAT_ERROR_ID :: Id

- MkCore: rEC_CON_ERROR_ID :: Id

- MkCore: rEC_SEL_ERROR_ID :: Id

- MkCore: rUNTIME_ERROR_ID :: Id

- MkCore: sortQuantVars :: [Var] -> [Var]

- MkCore: tYPE_ERROR_ID :: Id

- MkCore: unitExpr :: CoreExpr

- MkCore: wrapFloat :: FloatBind -> CoreExpr -> CoreExpr

- MkCore: wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr

- MkId: unsafeCoerceId :: Id

- MkId: unsafeCoerceName :: Name

- Outputable: updSDocDynFlags :: (DynFlags -> DynFlags) -> SDoc -> SDoc

- Outputable: withPprStyleDoc :: DynFlags -> PprStyle -> SDoc -> Doc

- Packages: BrokenDependencies :: [InstalledUnitId] -> UnusablePackageReason

- Packages: CyclicDependencies :: [InstalledUnitId] -> UnusablePackageReason

- Packages: IgnoredDependencies :: [InstalledUnitId] -> UnusablePackageReason

- Packages: IgnoredWithFlag :: UnusablePackageReason

- Packages: LookupFound :: Module -> UnitInfo -> LookupResult

- Packages: LookupHidden :: [(Module, ModuleOrigin)] -> [(Module, ModuleOrigin)] -> LookupResult

- Packages: LookupMultiple :: [(Module, ModuleOrigin)] -> LookupResult

- Packages: LookupNotFound :: [ModuleSuggestion] -> LookupResult

- Packages: LookupUnusable :: [(Module, ModuleOrigin)] -> LookupResult

- Packages: ModHidden :: ModuleOrigin

- Packages: ModOrigin :: Maybe Bool -> [UnitInfo] -> [UnitInfo] -> Bool -> ModuleOrigin

- Packages: ModUnusable :: UnusablePackageReason -> ModuleOrigin

- Packages: PackageDatabase :: FilePath -> [UnitInfo] -> PackageDatabase

- Packages: ShadowedDependencies :: [InstalledUnitId] -> UnusablePackageReason

- Packages: SuggestHidden :: ModuleName -> Module -> ModuleOrigin -> ModuleSuggestion

- Packages: SuggestVisible :: ModuleName -> Module -> ModuleOrigin -> ModuleSuggestion

- Packages: [fromExposedReexport] :: ModuleOrigin -> [UnitInfo]

- Packages: [fromHiddenReexport] :: ModuleOrigin -> [UnitInfo]

- Packages: [fromOrigPackage] :: ModuleOrigin -> Maybe Bool

- Packages: [fromPackageFlag] :: ModuleOrigin -> Bool

- Packages: [packageDatabasePath] :: PackageDatabase -> FilePath

- Packages: [packageDatabaseUnits] :: PackageDatabase -> [UnitInfo]

- Packages: collectArchives :: DynFlags -> UnitInfo -> IO [FilePath]

- Packages: collectIncludeDirs :: [UnitInfo] -> [FilePath]

- Packages: collectLibraryPaths :: DynFlags -> [UnitInfo] -> [FilePath]

- Packages: collectLinkOpts :: DynFlags -> [UnitInfo] -> ([String], [String], [String])

- Packages: componentIdString :: DynFlags -> ComponentId -> Maybe String

- Packages: data LookupResult

- Packages: data ModuleOrigin

- Packages: data ModuleSuggestion

- Packages: data PackageDatabase

- Packages: data PackageState

- Packages: data UnitInfoMap

- Packages: data UnusablePackageReason

- Packages: displayInstalledUnitId :: DynFlags -> InstalledUnitId -> Maybe String

- Packages: emptyPackageState :: PackageState

- Packages: getInstalledPackageDetails :: HasDebugCallStack => DynFlags -> InstalledUnitId -> UnitInfo

- Packages: getLibs :: DynFlags -> [PreloadUnitId] -> IO [(String, String)]

- Packages: getPackageConfRefs :: DynFlags -> IO [PkgDbRef]

- Packages: getPackageDetails :: HasDebugCallStack => DynFlags -> UnitId -> UnitInfo

- Packages: getPackageExtraCcOpts :: DynFlags -> [PreloadUnitId] -> IO [String]

- Packages: getPackageFrameworkPath :: DynFlags -> [PreloadUnitId] -> IO [String]

- Packages: getPackageFrameworks :: DynFlags -> [PreloadUnitId] -> IO [String]

- Packages: getPackageIncludePath :: DynFlags -> [PreloadUnitId] -> IO [String]

- Packages: getPackageLibraryPath :: DynFlags -> [PreloadUnitId] -> IO [String]

- Packages: getPackageLinkOpts :: DynFlags -> [PreloadUnitId] -> IO ([String], [String], [String])

- Packages: getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [UnitInfo]

- Packages: getUnitInfoMap :: DynFlags -> UnitInfoMap

- Packages: improveUnitId :: UnitInfoMap -> UnitId -> UnitId

- Packages: initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId])

- Packages: instance GHC.Base.Monoid Packages.ModuleOrigin

- Packages: instance GHC.Base.Monoid Packages.UnitVisibility

- Packages: instance GHC.Base.Semigroup Packages.ModuleOrigin

- Packages: instance GHC.Base.Semigroup Packages.UnitVisibility

- Packages: instance Outputable.Outputable Packages.ModuleOrigin

- Packages: instance Outputable.Outputable Packages.UnitVisibility

- Packages: instance Outputable.Outputable Packages.UnusablePackageReason

- Packages: isDllName :: DynFlags -> Module -> Name -> Bool

- Packages: isIndefinite :: DynFlags -> Bool

- Packages: listUnitInfoMap :: DynFlags -> [UnitInfo]

- Packages: listVisibleModuleNames :: DynFlags -> [ModuleName]

- Packages: lookupInstalledPackage :: DynFlags -> InstalledUnitId -> Maybe UnitInfo

- Packages: lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, UnitInfo)]

- Packages: lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult

- Packages: lookupPackageName :: DynFlags -> PackageName -> Maybe ComponentId

- Packages: lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult

- Packages: lookupUnit :: DynFlags -> UnitId -> Maybe UnitInfo

- Packages: lookupUnit' :: Bool -> UnitInfoMap -> UnitId -> Maybe UnitInfo

- Packages: packageHsLibs :: DynFlags -> UnitInfo -> [String]

- Packages: pprFlag :: PackageFlag -> SDoc

- Packages: pprModuleMap :: ModuleNameProvidersMap -> SDoc

- Packages: pprPackages :: DynFlags -> SDoc

- Packages: pprPackagesSimple :: DynFlags -> SDoc

- Packages: pprReason :: SDoc -> UnusablePackageReason -> SDoc

- Packages: readPackageDatabase :: DynFlags -> FilePath -> IO PackageDatabase

- Packages: readPackageDatabases :: DynFlags -> IO [PackageDatabase]

- Packages: resolvePackageDatabase :: DynFlags -> PkgDbRef -> IO (Maybe FilePath)

- Packages: searchPackageId :: DynFlags -> SourcePackageId -> [UnitInfo]

- Packages: unwireUnitId :: DynFlags -> UnitId -> UnitId

- PipelineMonad: HscOut :: HscSource -> ModuleName -> HscStatus -> PhasePlus

- PipelineMonad: P :: (PipeEnv -> PipeState -> IO (PipeState, a)) -> CompPipeline a

- PipelineMonad: Persistent :: PipelineOutput

- PipelineMonad: PipeEnv :: Phase -> String -> String -> String -> PipelineOutput -> PipeEnv

- PipelineMonad: PipeState :: HscEnv -> Maybe ModLocation -> [FilePath] -> Maybe (ModIface, ModDetails) -> PipeState

- PipelineMonad: RealPhase :: Phase -> PhasePlus

- PipelineMonad: SpecificFile :: PipelineOutput

- PipelineMonad: Temporary :: TempFileLifetime -> PipelineOutput

- PipelineMonad: [foreign_os] :: PipeState -> [FilePath]

- PipelineMonad: [hsc_env] :: PipeState -> HscEnv

- PipelineMonad: [iface] :: PipeState -> Maybe (ModIface, ModDetails)

- PipelineMonad: [maybe_loc] :: PipeState -> Maybe ModLocation

- PipelineMonad: [output_spec] :: PipeEnv -> PipelineOutput

- PipelineMonad: [src_basename] :: PipeEnv -> String

- PipelineMonad: [src_filename] :: PipeEnv -> String

- PipelineMonad: [src_suffix] :: PipeEnv -> String

- PipelineMonad: [stop_phase] :: PipeEnv -> Phase

- PipelineMonad: [unP] :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)

- PipelineMonad: data PhasePlus

- PipelineMonad: data PipeEnv

- PipelineMonad: data PipeState

- PipelineMonad: data PipelineOutput

- PipelineMonad: evalP :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)

- PipelineMonad: getPipeEnv :: CompPipeline PipeEnv

- PipelineMonad: getPipeState :: CompPipeline PipeState

- PipelineMonad: instance Control.Monad.IO.Class.MonadIO PipelineMonad.CompPipeline

- PipelineMonad: instance DynFlags.HasDynFlags PipelineMonad.CompPipeline

- PipelineMonad: instance GHC.Base.Applicative PipelineMonad.CompPipeline

- PipelineMonad: instance GHC.Base.Functor PipelineMonad.CompPipeline

- PipelineMonad: instance GHC.Base.Monad PipelineMonad.CompPipeline

- PipelineMonad: instance GHC.Show.Show PipelineMonad.PipelineOutput

- PipelineMonad: instance Outputable.Outputable PipelineMonad.PhasePlus

- PipelineMonad: newtype CompPipeline a

- PipelineMonad: pipeStateDynFlags :: PipeState -> DynFlags

- PipelineMonad: pipeStateModIface :: PipeState -> Maybe (ModIface, ModDetails)

- PipelineMonad: setDynFlags :: DynFlags -> CompPipeline ()

- PipelineMonad: setForeignOs :: [FilePath] -> CompPipeline ()

- PipelineMonad: setIface :: ModIface -> ModDetails -> CompPipeline ()

- PipelineMonad: setModLocation :: ModLocation -> CompPipeline ()

- Plugins: ForceRecompile :: PluginRecompile

- Plugins: FrontendPlugin :: FrontendPluginAction -> FrontendPlugin

- Plugins: LoadedPlugin :: PluginWithArgs -> ModIface -> LoadedPlugin

- Plugins: MaybeRecompile :: Fingerprint -> PluginRecompile

- Plugins: NoForceRecompile :: PluginRecompile

- Plugins: Plugin :: CorePlugin -> TcPlugin -> HoleFitPlugin -> ([CommandLineOption] -> DynFlags -> IO DynFlags) -> ([CommandLineOption] -> IO PluginRecompile) -> ([CommandLineOption] -> ModSummary -> HsParsedModule -> Hsc HsParsedModule) -> ([CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)) -> ([CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv) -> ([CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)) -> (forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface) -> Plugin

- Plugins: PluginWithArgs :: Plugin -> [CommandLineOption] -> PluginWithArgs

- Plugins: StaticPlugin :: PluginWithArgs -> StaticPlugin

- Plugins: [dynflagsPlugin] :: Plugin -> [CommandLineOption] -> DynFlags -> IO DynFlags

- Plugins: [frontend] :: FrontendPlugin -> FrontendPluginAction

- Plugins: [holeFitPlugin] :: Plugin -> HoleFitPlugin

- Plugins: [installCoreToDos] :: Plugin -> CorePlugin

- Plugins: [interfaceLoadAction] :: Plugin -> forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface

- Plugins: [lpModule] :: LoadedPlugin -> ModIface

- Plugins: [lpPlugin] :: LoadedPlugin -> PluginWithArgs

- Plugins: [paArguments] :: PluginWithArgs -> [CommandLineOption]

- Plugins: [paPlugin] :: PluginWithArgs -> Plugin

- Plugins: [parsedResultAction] :: Plugin -> [CommandLineOption] -> ModSummary -> HsParsedModule -> Hsc HsParsedModule

- Plugins: [pluginRecompile] :: Plugin -> [CommandLineOption] -> IO PluginRecompile

- Plugins: [renamedResultAction] :: Plugin -> [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

- Plugins: [spPlugin] :: StaticPlugin -> PluginWithArgs

- Plugins: [spliceRunAction] :: Plugin -> [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)

- Plugins: [tcPlugin] :: Plugin -> TcPlugin

- Plugins: [typeCheckResultAction] :: Plugin -> [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv

- Plugins: data FrontendPlugin

- Plugins: data HoleFitPluginR

- Plugins: data LoadedPlugin

- Plugins: data Plugin

- Plugins: data PluginRecompile

- Plugins: data PluginWithArgs

- Plugins: data StaticPlugin

- Plugins: defaultFrontendPlugin :: FrontendPlugin

- Plugins: defaultPlugin :: Plugin

- Plugins: flagRecompile :: [CommandLineOption] -> IO PluginRecompile

- Plugins: impurePlugin :: [CommandLineOption] -> IO PluginRecompile

- Plugins: instance GHC.Base.Monoid Plugins.PluginRecompile

- Plugins: instance GHC.Base.Semigroup Plugins.PluginRecompile

- Plugins: instance Outputable.Outputable Plugins.PluginRecompile

- Plugins: keepRenamedSource :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

- Plugins: lpModuleName :: LoadedPlugin -> ModuleName

- Plugins: mapPlugins :: DynFlags -> (Plugin -> [CommandLineOption] -> a) -> [a]

- Plugins: pluginRecompile' :: PluginWithArgs -> IO PluginRecompile

- Plugins: plugins :: DynFlags -> [PluginWithArgs]

- Plugins: purePlugin :: [CommandLineOption] -> IO PluginRecompile

- Plugins: type CommandLineOption = String

- Plugins: type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]

- Plugins: type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()

- Plugins: type TcPlugin = [CommandLineOption] -> Maybe TcPlugin

- Plugins: withPlugins :: Monad m => DynFlags -> PluginOperation m a -> a -> m a

- Plugins: withPlugins_ :: Monad m => DynFlags -> ConstPluginOperation m a -> a -> m ()

- PprCore: instance Outputable.Outputable CoreSyn.CoreRule

- PprCore: instance Outputable.Outputable CoreSyn.Unfolding

- PprCore: instance Outputable.Outputable CoreSyn.UnfoldingGuidance

- PprCore: instance Outputable.Outputable CoreSyn.UnfoldingSource

- PprCore: instance Outputable.Outputable b => Outputable.OutputableBndr (CoreSyn.TaggedBndr b)

- PprCore: instance Outputable.Outputable id => Outputable.Outputable (CoreSyn.Tickish id)

- PprCore: instance Outputable.OutputableBndr Var.Var

- PprCore: instance Outputable.OutputableBndr b => Outputable.Outputable (CoreSyn.Bind b)

- PprCore: instance Outputable.OutputableBndr b => Outputable.Outputable (CoreSyn.Expr b)

- PprCore: pprCoreAlt :: OutputableBndr a => (AltCon, [a], Expr a) -> SDoc

- PprCore: pprCoreBinding :: OutputableBndr b => Bind b -> SDoc

- PprCore: pprCoreBindingWithSize :: CoreBind -> SDoc

- PprCore: pprCoreBindings :: OutputableBndr b => [Bind b] -> SDoc

- PprCore: pprCoreBindingsWithSize :: [CoreBind] -> SDoc

- PprCore: pprCoreExpr :: OutputableBndr b => Expr b -> SDoc

- PprCore: pprOptCo :: Coercion -> SDoc

- PprCore: pprParendExpr :: OutputableBndr b => Expr b -> SDoc

- PprCore: pprRules :: [CoreRule] -> SDoc

- PrelRules: instance DynFlags.HasDynFlags PrelRules.RuleM

- RdrName: instance GHC.Classes.Ord RdrName.ImpDeclSpec

- RdrName: instance GHC.Classes.Ord RdrName.ImpItemSpec

- RdrName: instance GHC.Classes.Ord RdrName.ImportSpec

- Reg: RealRegPair :: {-# UNPACK #-} !RegNo -> {-# UNPACK #-} !RegNo -> RealReg

- Reg: RealRegSingle :: {-# UNPACK #-} !RegNo -> RealReg

- Reg: RegReal :: !RealReg -> Reg

- Reg: RegVirtual :: !VirtualReg -> Reg

- Reg: VirtualRegD :: {-# UNPACK #-} !Unique -> VirtualReg

- Reg: VirtualRegF :: {-# UNPACK #-} !Unique -> VirtualReg

- Reg: VirtualRegHi :: {-# UNPACK #-} !Unique -> VirtualReg

- Reg: VirtualRegI :: {-# UNPACK #-} !Unique -> VirtualReg

- Reg: classOfVirtualReg :: VirtualReg -> RegClass

- Reg: data RealReg

- Reg: data Reg

- Reg: data VirtualReg

- Reg: getHiVRegFromLo :: Reg -> Reg

- Reg: getHiVirtualRegFromLo :: VirtualReg -> VirtualReg

- Reg: instance GHC.Classes.Eq Reg.RealReg

- Reg: instance GHC.Classes.Eq Reg.Reg

- Reg: instance GHC.Classes.Eq Reg.VirtualReg

- Reg: instance GHC.Classes.Ord Reg.RealReg

- Reg: instance GHC.Classes.Ord Reg.Reg

- Reg: instance GHC.Classes.Ord Reg.VirtualReg

- Reg: instance GHC.Show.Show Reg.RealReg

- Reg: instance GHC.Show.Show Reg.VirtualReg

- Reg: instance Outputable.Outputable Reg.RealReg

- Reg: instance Outputable.Outputable Reg.Reg

- Reg: instance Outputable.Outputable Reg.VirtualReg

- Reg: instance Unique.Uniquable Reg.RealReg

- Reg: instance Unique.Uniquable Reg.Reg

- Reg: instance Unique.Uniquable Reg.VirtualReg

- Reg: isRealReg :: Reg -> Bool

- Reg: isVirtualReg :: Reg -> Bool

- Reg: liftPatchFnToRegReg :: (VirtualReg -> RealReg) -> Reg -> Reg

- Reg: realRegsAlias :: RealReg -> RealReg -> Bool

- Reg: regNosOfRealReg :: RealReg -> [RegNo]

- Reg: regPair :: RegNo -> RegNo -> Reg

- Reg: regSingle :: RegNo -> Reg

- Reg: renameVirtualReg :: Unique -> VirtualReg -> VirtualReg

- Reg: takeRealReg :: Reg -> Maybe RealReg

- Reg: takeVirtualReg :: Reg -> Maybe VirtualReg

- Reg: type RegNo = Int

- RegClass: RcDouble :: RegClass

- RegClass: RcFloat :: RegClass

- RegClass: RcInteger :: RegClass

- RegClass: data RegClass

- RegClass: instance GHC.Classes.Eq RegClass.RegClass

- RegClass: instance Outputable.Outputable RegClass.RegClass

- RegClass: instance Unique.Uniquable RegClass.RegClass

- Rules: addIdSpecialisations :: Id -> [CoreRule] -> Id

- Rules: addRuleInfo :: RuleInfo -> RuleInfo -> RuleInfo

- Rules: emptyRuleBase :: RuleBase

- Rules: extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase

- Rules: extendRuleInfo :: RuleInfo -> [CoreRule] -> RuleInfo

- Rules: getRules :: RuleEnv -> Id -> [CoreRule]

- Rules: lookupRule :: DynFlags -> InScopeEnv -> (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr)

- Rules: mkRule :: Module -> Bool -> Bool -> RuleName -> Activation -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule

- Rules: mkRuleBase :: [CoreRule] -> RuleBase

- Rules: mkRuleInfo :: [CoreRule] -> RuleInfo

- Rules: pprRuleBase :: RuleBase -> SDoc

- Rules: pprRulesForUser :: DynFlags -> [CoreRule] -> SDoc

- Rules: roughTopNames :: [CoreExpr] -> [Maybe Name]

- Rules: ruleCheckProgram :: CompilerPhase -> String -> (Id -> [CoreRule]) -> CoreProgram -> SDoc

- Rules: rulesOfBinds :: [CoreBind] -> [CoreRule]

- Rules: unionRuleBase :: RuleBase -> RuleBase -> RuleBase

- SrcLoc: instance GHC.Classes.Ord SrcLoc.SrcLoc

- SrcLoc: instance GHC.Classes.Ord SrcLoc.SrcSpan

- SrcLoc: rightmost :: SrcSpan -> SrcSpan -> Ordering

- TcOrigin: FailablePattern :: LPat GhcTcId -> CtOrigin

- TcRnTypes: [dsl_delta] :: DsLclEnv -> Delta

- TcRnTypes: instance DynFlags.ContainsDynFlags (TcRnTypes.Env gbl lcl)

- TyCoFVs: exactTyCoVarsOfType :: Type -> TyCoVarSet

- TyCoFVs: exactTyCoVarsOfTypes :: [Type] -> TyVarSet

- TyCoFVs: mkTyCoInScopeSet :: [Type] -> [Coercion] -> InScopeSet

- TyCoFVs: tyCoVarsOfCosSet :: CoVarEnv Coercion -> TyCoVarSet

- TyCoFVs: tyCoVarsOfProv :: UnivCoProvenance -> TyCoVarSet

- TyCoFVs: tyCoVarsOfTypesSet :: TyVarEnv Type -> TyCoVarSet

- TyCoRep: UnsafeCoerceProv :: UnivCoProvenance

- TyCoSubst: mkTyCoInScopeSet :: [Type] -> [Coercion] -> InScopeSet

- TyCon: instance Outputable.Outputable tv => Outputable.Outputable (Var.VarBndr tv TyCon.TyConBndrVis)

- Type: closeOverKindsFV :: [TyVar] -> FV

+ ApiAnnotation: ApiAnns :: Map ApiAnnKey [RealSrcSpan] -> Maybe RealSrcSpan -> Map RealSrcSpan [RealLocated AnnotationComment] -> [RealLocated AnnotationComment] -> ApiAnns

+ ApiAnnotation: [apiAnnComments] :: ApiAnns -> Map RealSrcSpan [RealLocated AnnotationComment]

+ ApiAnnotation: [apiAnnEofPos] :: ApiAnns -> Maybe RealSrcSpan

+ ApiAnnotation: [apiAnnItems] :: ApiAnns -> Map ApiAnnKey [RealSrcSpan]

+ ApiAnnotation: [apiAnnRogueComments] :: ApiAnns -> [RealLocated AnnotationComment]

+ ApiAnnotation: data ApiAnns

+ BasicTypes: instance Outputable.Outputable BasicTypes.PromotionFlag

+ Binary: instance Binary.Binary SrcLoc.BufPos

+ Binary: instance Binary.Binary SrcLoc.BufSpan

+ CoreMonad: CoreDoCpr :: CoreToDo

+ CoreMonad: CoreDoDemand :: CoreToDo

+ CoreMonad: instance GHC.Driver.Session.HasDynFlags CoreMonad.CoreM

+ Cpr: CprSig :: CprType -> CprSig

+ Cpr: CprType :: !Arity -> !CprResult -> CprType

+ Cpr: [ct_arty] :: CprType -> !Arity

+ Cpr: [ct_cpr] :: CprType -> !CprResult

+ Cpr: [getCprSig] :: CprSig -> CprType

+ Cpr: abstractCprTy :: CprType -> CprType

+ Cpr: applyCprTy :: CprType -> CprType

+ Cpr: asConCpr :: CprResult -> Maybe ConTag

+ Cpr: botCpr :: CprResult

+ Cpr: botCprType :: CprType

+ Cpr: conCpr :: ConTag -> CprResult

+ Cpr: conCprType :: ConTag -> CprType

+ Cpr: data CprResult

+ Cpr: data CprType

+ Cpr: ensureCprTyArity :: Arity -> CprType -> CprType

+ Cpr: instance Binary.Binary Cpr.CprResult

+ Cpr: instance Binary.Binary Cpr.CprSig

+ Cpr: instance Binary.Binary Cpr.CprType

+ Cpr: instance GHC.Classes.Eq Cpr.CprResult

+ Cpr: instance GHC.Classes.Eq Cpr.CprSig

+ Cpr: instance GHC.Classes.Eq Cpr.CprType

+ Cpr: instance GHC.Show.Show Cpr.CprResult

+ Cpr: instance Outputable.Outputable Cpr.CprResult

+ Cpr: instance Outputable.Outputable Cpr.CprSig

+ Cpr: instance Outputable.Outputable Cpr.CprType

+ Cpr: lubCprType :: CprType -> CprType -> CprType

+ Cpr: mkCprSig :: Arity -> CprResult -> CprSig

+ Cpr: mkCprSigForArity :: Arity -> CprType -> CprSig

+ Cpr: newtype CprSig

+ Cpr: seqCprSig :: CprSig -> ()

+ Cpr: topCpr :: CprResult

+ Cpr: topCprSig :: CprSig

+ Cpr: topCprType :: CprType

+ Cpr: trimCprTy :: CprType -> CprType

+ Demand: Diverges :: Divergence

+ Demand: Dunno :: Divergence

+ Demand: botDiv :: Divergence

+ Demand: data Divergence

+ Demand: instance Binary.Binary Demand.Divergence

+ Demand: instance GHC.Classes.Eq Demand.Divergence

+ Demand: instance GHC.Show.Show Demand.Divergence

+ Demand: instance Outputable.Outputable Demand.Divergence

+ Demand: isBotDiv :: Divergence -> Bool

+ Demand: isTopDiv :: Divergence -> Bool

+ Demand: lubDivergence :: Divergence -> Divergence -> Divergence

+ Demand: topDiv :: Divergence

+ GHC.ByteCode.Types: BCONPtrItbl :: !Name -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrLbl :: !FastString -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrStr :: !ByteString -> BCONPtr

+ GHC.ByteCode.Types: BCONPtrWord :: {-# UNPACK #-} !Word -> BCONPtr

+ GHC.ByteCode.Types: BCOPtrBCO :: !UnlinkedBCO -> BCOPtr

+ GHC.ByteCode.Types: BCOPtrBreakArray :: BCOPtr

+ GHC.ByteCode.Types: BCOPtrName :: !Name -> BCOPtr

+ GHC.ByteCode.Types: BCOPtrPrimOp :: !PrimOp -> BCOPtr

+ GHC.ByteCode.Types: CgBreakInfo :: [Maybe (Id, Word16)] -> Type -> CgBreakInfo

+ GHC.ByteCode.Types: CompiledByteCode :: [UnlinkedBCO] -> ItblEnv -> [FFIInfo] -> [RemotePtr ()] -> Maybe ModBreaks -> CompiledByteCode

+ GHC.ByteCode.Types: FFIInfo :: RemotePtr C_ffi_cif -> FFIInfo

+ GHC.ByteCode.Types: ItblPtr :: RemotePtr StgInfoTable -> ItblPtr

+ GHC.ByteCode.Types: ModBreaks :: ForeignRef BreakArray -> !Array BreakIndex SrcSpan -> !Array BreakIndex [OccName] -> !Array BreakIndex [String] -> !Array BreakIndex (RemotePtr CostCentre) -> IntMap CgBreakInfo -> ModBreaks

+ GHC.ByteCode.Types: UnlinkedBCO :: !Name -> {-# UNPACK #-} !Int -> !UArray Int Word16 -> !UArray Int Word64 -> !SizedSeq BCONPtr -> !SizedSeq BCOPtr -> UnlinkedBCO

+ GHC.ByteCode.Types: [bc_bcos] :: CompiledByteCode -> [UnlinkedBCO]

+ GHC.ByteCode.Types: [bc_breaks] :: CompiledByteCode -> Maybe ModBreaks

+ GHC.ByteCode.Types: [bc_ffis] :: CompiledByteCode -> [FFIInfo]

+ GHC.ByteCode.Types: [bc_itbls] :: CompiledByteCode -> ItblEnv

+ GHC.ByteCode.Types: [bc_strs] :: CompiledByteCode -> [RemotePtr ()]

+ GHC.ByteCode.Types: [cgb_resty] :: CgBreakInfo -> Type

+ GHC.ByteCode.Types: [cgb_vars] :: CgBreakInfo -> [Maybe (Id, Word16)]

+ GHC.ByteCode.Types: [modBreaks_breakInfo] :: ModBreaks -> IntMap CgBreakInfo

+ GHC.ByteCode.Types: [modBreaks_ccs] :: ModBreaks -> !Array BreakIndex (RemotePtr CostCentre)

+ GHC.ByteCode.Types: [modBreaks_decls] :: ModBreaks -> !Array BreakIndex [String]

+ GHC.ByteCode.Types: [modBreaks_flags] :: ModBreaks -> ForeignRef BreakArray

+ GHC.ByteCode.Types: [modBreaks_locs] :: ModBreaks -> !Array BreakIndex SrcSpan

+ GHC.ByteCode.Types: [modBreaks_vars] :: ModBreaks -> !Array BreakIndex [OccName]

+ GHC.ByteCode.Types: [unlinkedBCOArity] :: UnlinkedBCO -> {-# UNPACK #-} !Int

+ GHC.ByteCode.Types: [unlinkedBCOBitmap] :: UnlinkedBCO -> !UArray Int Word64

+ GHC.ByteCode.Types: [unlinkedBCOInstrs] :: UnlinkedBCO -> !UArray Int Word16

+ GHC.ByteCode.Types: [unlinkedBCOLits] :: UnlinkedBCO -> !SizedSeq BCONPtr

+ GHC.ByteCode.Types: [unlinkedBCOName] :: UnlinkedBCO -> !Name

+ GHC.ByteCode.Types: [unlinkedBCOPtrs] :: UnlinkedBCO -> !SizedSeq BCOPtr

+ GHC.ByteCode.Types: data BCONPtr

+ GHC.ByteCode.Types: data BCOPtr

+ GHC.ByteCode.Types: data CCostCentre

+ GHC.ByteCode.Types: data CgBreakInfo

+ GHC.ByteCode.Types: data CompiledByteCode

+ GHC.ByteCode.Types: data ModBreaks

+ GHC.ByteCode.Types: data UnlinkedBCO

+ GHC.ByteCode.Types: emptyModBreaks :: ModBreaks

+ GHC.ByteCode.Types: instance Control.DeepSeq.NFData GHC.ByteCode.Types.BCONPtr

+ GHC.ByteCode.Types: instance Control.DeepSeq.NFData GHC.ByteCode.Types.BCOPtr

+ GHC.ByteCode.Types: instance Control.DeepSeq.NFData GHC.ByteCode.Types.FFIInfo

+ GHC.ByteCode.Types: instance Control.DeepSeq.NFData GHC.ByteCode.Types.ItblPtr

+ GHC.ByteCode.Types: instance Control.DeepSeq.NFData GHC.ByteCode.Types.UnlinkedBCO

+ GHC.ByteCode.Types: instance GHC.Show.Show GHC.ByteCode.Types.FFIInfo

+ GHC.ByteCode.Types: instance GHC.Show.Show GHC.ByteCode.Types.ItblPtr

+ GHC.ByteCode.Types: instance Outputable.Outputable GHC.ByteCode.Types.CgBreakInfo

+ GHC.ByteCode.Types: instance Outputable.Outputable GHC.ByteCode.Types.CompiledByteCode

+ GHC.ByteCode.Types: instance Outputable.Outputable GHC.ByteCode.Types.UnlinkedBCO

+ GHC.ByteCode.Types: newtype FFIInfo

+ GHC.ByteCode.Types: newtype ItblPtr

+ GHC.ByteCode.Types: seqCompiledByteCode :: CompiledByteCode -> ()

+ GHC.ByteCode.Types: type BreakIndex = Int

+ GHC.ByteCode.Types: type ItblEnv = NameEnv (Name, ItblPtr)

+ GHC.Cmm: CmmStatics :: CLabel -> CmmInfoTable -> CostCentreStack -> [CmmLit] -> CmmStatics

+ GHC.Cmm: CmmStaticsRaw :: CLabel -> [CmmStatic] -> CmmStatics

+ GHC.Cmm: RawCmmStatics :: CLabel -> [CmmStatic] -> RawCmmStatics

+ GHC.Cmm: data RawCmmStatics

+ GHC.Cmm: type CmmDeclSRTs = GenCmmDecl RawCmmStatics CmmTopInfo CmmGraph

+ GHC.Cmm: type CmmGroupSRTs = GenCmmGroup RawCmmStatics CmmTopInfo CmmGraph

+ GHC.Cmm.CLabel: isIdLabel :: CLabel -> Bool

+ GHC.Core: AnnApp :: AnnExpr bndr annot -> AnnExpr bndr annot -> AnnExpr' bndr annot

+ GHC.Core: AnnCase :: AnnExpr bndr annot -> bndr -> Type -> [AnnAlt bndr annot] -> AnnExpr' bndr annot

+ GHC.Core: AnnCast :: AnnExpr bndr annot -> (annot, Coercion) -> AnnExpr' bndr annot

+ GHC.Core: AnnCoercion :: Coercion -> AnnExpr' bndr annot

+ GHC.Core: AnnLam :: bndr -> AnnExpr bndr annot -> AnnExpr' bndr annot

+ GHC.Core: AnnLet :: AnnBind bndr annot -> AnnExpr bndr annot -> AnnExpr' bndr annot

+ GHC.Core: AnnLit :: Literal -> AnnExpr' bndr annot

+ GHC.Core: AnnNonRec :: bndr -> AnnExpr bndr annot -> AnnBind bndr annot

+ GHC.Core: AnnRec :: [(bndr, AnnExpr bndr annot)] -> AnnBind bndr annot

+ GHC.Core: AnnTick :: Tickish Id -> AnnExpr bndr annot -> AnnExpr' bndr annot

+ GHC.Core: AnnType :: Type -> AnnExpr' bndr annot

+ GHC.Core: AnnVar :: Id -> AnnExpr' bndr annot

+ GHC.Core: App :: Expr b -> Arg b -> Expr b

+ GHC.Core: BootUnfolding :: Unfolding

+ GHC.Core: Breakpoint :: !Int -> [id] -> Tickish id

+ GHC.Core: BuiltinRule :: RuleName -> Name -> Int -> RuleFun -> CoreRule

+ GHC.Core: Case :: Expr b -> b -> Type -> [Alt b] -> Expr b

+ GHC.Core: Cast :: Expr b -> Coercion -> Expr b

+ GHC.Core: Coercion :: Coercion -> Expr b

+ GHC.Core: CoreUnfolding :: CoreExpr -> UnfoldingSource -> Bool -> Bool -> Bool -> Bool -> Bool -> UnfoldingGuidance -> Unfolding

+ GHC.Core: CostCentreScope :: TickishScoping

+ GHC.Core: DEFAULT :: AltCon

+ GHC.Core: DFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding

+ GHC.Core: DataAlt :: DataCon -> AltCon

+ GHC.Core: HpcTick :: Module -> !Int -> Tickish id

+ GHC.Core: InlineCompulsory :: UnfoldingSource

+ GHC.Core: InlineRhs :: UnfoldingSource

+ GHC.Core: InlineStable :: UnfoldingSource

+ GHC.Core: IsOrphan :: IsOrphan

+ GHC.Core: Lam :: b -> Expr b -> Expr b

+ GHC.Core: Let :: Bind b -> Expr b -> Expr b

+ GHC.Core: Lit :: Literal -> Expr b

+ GHC.Core: LitAlt :: Literal -> AltCon

+ GHC.Core: NoScope :: TickishScoping

+ GHC.Core: NoUnfolding :: Unfolding

+ GHC.Core: NonRec :: b -> Expr b -> Bind b

+ GHC.Core: NotOrphan :: OccName -> IsOrphan

+ GHC.Core: OtherCon :: [AltCon] -> Unfolding

+ GHC.Core: PlaceCostCentre :: TickishPlacement

+ GHC.Core: PlaceNonLam :: TickishPlacement

+ GHC.Core: PlaceRuntime :: TickishPlacement

+ GHC.Core: ProfNote :: CostCentre -> !Bool -> !Bool -> Tickish id

+ GHC.Core: Rec :: [(b, Expr b)] -> Bind b

+ GHC.Core: Rule :: RuleName -> Activation -> Name -> [Maybe Name] -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> Bool -> !Module -> !IsOrphan -> Bool -> CoreRule

+ GHC.Core: RuleEnv :: RuleBase -> ModuleSet -> RuleEnv

+ GHC.Core: SoftScope :: TickishScoping

+ GHC.Core: SourceNote :: RealSrcSpan -> String -> Tickish id

+ GHC.Core: TB :: CoreBndr -> t -> TaggedBndr t

+ GHC.Core: Tick :: Tickish Id -> Expr b -> Expr b

+ GHC.Core: Type :: Type -> Expr b

+ GHC.Core: UnfIfGoodArgs :: [Int] -> Int -> Int -> UnfoldingGuidance

+ GHC.Core: UnfNever :: UnfoldingGuidance

+ GHC.Core: UnfWhen :: Arity -> Bool -> Bool -> UnfoldingGuidance

+ GHC.Core: Var :: Id -> Expr b

+ GHC.Core: [breakpointFVs] :: Tickish id -> [id]

+ GHC.Core: [breakpointId] :: Tickish id -> !Int

+ GHC.Core: [df_args] :: Unfolding -> [CoreExpr]

+ GHC.Core: [df_bndrs] :: Unfolding -> [Var]

+ GHC.Core: [df_con] :: Unfolding -> DataCon

+ GHC.Core: [profNoteCC] :: Tickish id -> CostCentre

+ GHC.Core: [profNoteCount] :: Tickish id -> !Bool

+ GHC.Core: [profNoteScope] :: Tickish id -> !Bool

+ GHC.Core: [re_base] :: RuleEnv -> RuleBase

+ GHC.Core: [re_visible_orphs] :: RuleEnv -> ModuleSet

+ GHC.Core: [ru_act] :: CoreRule -> Activation

+ GHC.Core: [ru_args] :: CoreRule -> [CoreExpr]

+ GHC.Core: [ru_auto] :: CoreRule -> Bool

+ GHC.Core: [ru_bndrs] :: CoreRule -> [CoreBndr]

+ GHC.Core: [ru_fn] :: CoreRule -> Name

+ GHC.Core: [ru_local] :: CoreRule -> Bool

+ GHC.Core: [ru_name] :: CoreRule -> RuleName

+ GHC.Core: [ru_nargs] :: CoreRule -> Int

+ GHC.Core: [ru_origin] :: CoreRule -> !Module

+ GHC.Core: [ru_orphan] :: CoreRule -> !IsOrphan

+ GHC.Core: [ru_rhs] :: CoreRule -> CoreExpr

+ GHC.Core: [ru_rough] :: CoreRule -> [Maybe Name]

+ GHC.Core: [ru_try] :: CoreRule -> RuleFun

+ GHC.Core: [sourceName] :: Tickish id -> String

+ GHC.Core: [sourceSpan] :: Tickish id -> RealSrcSpan

+ GHC.Core: [tickId] :: Tickish id -> !Int

+ GHC.Core: [tickModule] :: Tickish id -> Module

+ GHC.Core: [uf_expandable] :: Unfolding -> Bool

+ GHC.Core: [uf_guidance] :: Unfolding -> UnfoldingGuidance

+ GHC.Core: [uf_is_conlike] :: Unfolding -> Bool

+ GHC.Core: [uf_is_top] :: Unfolding -> Bool

+ GHC.Core: [uf_is_value] :: Unfolding -> Bool

+ GHC.Core: [uf_is_work_free] :: Unfolding -> Bool

+ GHC.Core: [uf_src] :: Unfolding -> UnfoldingSource

+ GHC.Core: [uf_tmpl] :: Unfolding -> CoreExpr

+ GHC.Core: [ug_args] :: UnfoldingGuidance -> [Int]

+ GHC.Core: [ug_arity] :: UnfoldingGuidance -> Arity

+ GHC.Core: [ug_boring_ok] :: UnfoldingGuidance -> Bool

+ GHC.Core: [ug_res] :: UnfoldingGuidance -> Int

+ GHC.Core: [ug_size] :: UnfoldingGuidance -> Int

+ GHC.Core: [ug_unsat_ok] :: UnfoldingGuidance -> Bool

+ GHC.Core: applyTypeToArg :: Type -> CoreExpr -> Type

+ GHC.Core: bindersOf :: Bind b -> [b]

+ GHC.Core: bindersOfBinds :: [Bind b] -> [b]

+ GHC.Core: bootUnfolding :: Unfolding

+ GHC.Core: boringCxtNotOk :: Bool

+ GHC.Core: boringCxtOk :: Bool

+ GHC.Core: canUnfold :: Unfolding -> Bool

+ GHC.Core: chooseOrphanAnchor :: NameSet -> IsOrphan

+ GHC.Core: cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering

+ GHC.Core: cmpAltCon :: AltCon -> AltCon -> Ordering

+ GHC.Core: collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])

+ GHC.Core: collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])

+ GHC.Core: collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

+ GHC.Core: collectArgs :: Expr b -> (Expr b, [Arg b])

+ GHC.Core: collectArgsTicks :: (Tickish Id -> Bool) -> Expr b -> (Expr b, [Arg b], [Tickish Id])

+ GHC.Core: collectBinders :: Expr b -> ([b], Expr b)

+ GHC.Core: collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

+ GHC.Core: collectNBinders :: Int -> Expr b -> ([b], Expr b)

+ GHC.Core: collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)

+ GHC.Core: collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)

+ GHC.Core: data AltCon

+ GHC.Core: data AnnBind bndr annot

+ GHC.Core: data AnnExpr' bndr annot

+ GHC.Core: data Bind b

+ GHC.Core: data CoreRule

+ GHC.Core: data Expr b

+ GHC.Core: data IsOrphan

+ GHC.Core: data RuleEnv

+ GHC.Core: data TaggedBndr t

+ GHC.Core: data Tickish id

+ GHC.Core: data TickishPlacement

+ GHC.Core: data TickishScoping

+ GHC.Core: data Unfolding

+ GHC.Core: data UnfoldingGuidance

+ GHC.Core: data UnfoldingSource

+ GHC.Core: deAnnAlt :: AnnAlt bndr annot -> Alt bndr

+ GHC.Core: deAnnBind :: AnnBind b annot -> Bind b

+ GHC.Core: deAnnotate :: AnnExpr bndr annot -> Expr bndr

+ GHC.Core: deAnnotate' :: AnnExpr' bndr annot -> Expr bndr

+ GHC.Core: deTagExpr :: TaggedExpr t -> CoreExpr

+ GHC.Core: emptyRuleEnv :: RuleEnv

+ GHC.Core: evaldUnfolding :: Unfolding

+ GHC.Core: expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr

+ GHC.Core: exprToCoercion_maybe :: CoreExpr -> Maybe Coercion

+ GHC.Core: exprToType :: CoreExpr -> Type

+ GHC.Core: flattenBinds :: [Bind b] -> [(b, Expr b)]

+ GHC.Core: hasSomeUnfolding :: Unfolding -> Bool

+ GHC.Core: infixl 4 `mkVarApps`

+ GHC.Core: instance Binary.Binary GHC.Core.IsOrphan

+ GHC.Core: instance Data.Data.Data GHC.Core.AltCon

+ GHC.Core: instance Data.Data.Data GHC.Core.IsOrphan

+ GHC.Core: instance Data.Data.Data b => Data.Data.Data (GHC.Core.Bind b)

+ GHC.Core: instance Data.Data.Data b => Data.Data.Data (GHC.Core.Expr b)

+ GHC.Core: instance Data.Data.Data id => Data.Data.Data (GHC.Core.Tickish id)

+ GHC.Core: instance GHC.Classes.Eq GHC.Core.AltCon

+ GHC.Core: instance GHC.Classes.Eq GHC.Core.TickishPlacement

+ GHC.Core: instance GHC.Classes.Eq GHC.Core.TickishScoping

+ GHC.Core: instance GHC.Classes.Eq GHC.Core.UnfoldingGuidance

+ GHC.Core: instance GHC.Classes.Eq id => GHC.Classes.Eq (GHC.Core.Tickish id)

+ GHC.Core: instance GHC.Classes.Ord GHC.Core.AltCon

+ GHC.Core: instance GHC.Classes.Ord id => GHC.Classes.Ord (GHC.Core.Tickish id)

+ GHC.Core: instance Outputable.Outputable GHC.Core.AltCon

+ GHC.Core: instance Outputable.Outputable b => Outputable.Outputable (GHC.Core.TaggedBndr b)

+ GHC.Core: isAutoRule :: CoreRule -> Bool

+ GHC.Core: isBootUnfolding :: Unfolding -> Bool

+ GHC.Core: isBuiltinRule :: CoreRule -> Bool

+ GHC.Core: isCheapUnfolding :: Unfolding -> Bool

+ GHC.Core: isCoArg :: Expr b -> Bool

+ GHC.Core: isCompulsoryUnfolding :: Unfolding -> Bool

+ GHC.Core: isConLikeUnfolding :: Unfolding -> Bool

+ GHC.Core: isEvaldUnfolding :: Unfolding -> Bool

+ GHC.Core: isExpandableUnfolding :: Unfolding -> Bool

+ GHC.Core: isFragileUnfolding :: Unfolding -> Bool

+ GHC.Core: isId :: Var -> Bool

+ GHC.Core: isLocalRule :: CoreRule -> Bool

+ GHC.Core: isOrphan :: IsOrphan -> Bool

+ GHC.Core: isRuntimeArg :: CoreExpr -> Bool

+ GHC.Core: isRuntimeVar :: Var -> Bool

+ GHC.Core: isStableSource :: UnfoldingSource -> Bool

+ GHC.Core: isStableUnfolding :: Unfolding -> Bool

+ GHC.Core: isTyCoArg :: Expr b -> Bool

+ GHC.Core: isTypeArg :: Expr b -> Bool

+ GHC.Core: isValArg :: Expr b -> Bool

+ GHC.Core: isValueUnfolding :: Unfolding -> Bool

+ GHC.Core: ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool

+ GHC.Core: maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr

+ GHC.Core: mkApps :: Expr b -> [Arg b] -> Expr b

+ GHC.Core: mkCharLit :: Char -> Expr b

+ GHC.Core: mkCoApps :: Expr b -> [Coercion] -> Expr b

+ GHC.Core: mkCoBind :: CoVar -> Coercion -> CoreBind

+ GHC.Core: mkConApp :: DataCon -> [Arg b] -> Expr b

+ GHC.Core: mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b

+ GHC.Core: mkDoubleLit :: Rational -> Expr b

+ GHC.Core: mkDoubleLitDouble :: Double -> Expr b

+ GHC.Core: mkFloatLit :: Rational -> Expr b

+ GHC.Core: mkFloatLitFloat :: Float -> Expr b

+ GHC.Core: mkInt64LitInt64 :: Int64 -> Expr b

+ GHC.Core: mkIntLit :: DynFlags -> Integer -> Expr b

+ GHC.Core: mkIntLitInt :: DynFlags -> Int -> Expr b

+ GHC.Core: mkLams :: [b] -> Expr b -> Expr b

+ GHC.Core: mkLet :: Bind b -> Expr b -> Expr b

+ GHC.Core: mkLetNonRec :: b -> Expr b -> Expr b -> Expr b

+ GHC.Core: mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b

+ GHC.Core: mkLets :: [Bind b] -> Expr b -> Expr b

+ GHC.Core: mkNoCount :: Tickish id -> Tickish id

+ GHC.Core: mkNoScope :: Tickish id -> Tickish id

+ GHC.Core: mkOtherCon :: [AltCon] -> Unfolding

+ GHC.Core: mkRuleEnv :: RuleBase -> [Module] -> RuleEnv

+ GHC.Core: mkStringLit :: String -> Expr b

+ GHC.Core: mkTyApps :: Expr b -> [Type] -> Expr b

+ GHC.Core: mkTyArg :: Type -> Expr b

+ GHC.Core: mkTyBind :: TyVar -> Type -> CoreBind

+ GHC.Core: mkVarApps :: Expr b -> [Var] -> Expr b

+ GHC.Core: mkWord64LitWord64 :: Word64 -> Expr b

+ GHC.Core: mkWordLit :: DynFlags -> Integer -> Expr b

+ GHC.Core: mkWordLitWord :: DynFlags -> Word -> Expr b

+ GHC.Core: needSaturated :: Bool

+ GHC.Core: neverUnfoldGuidance :: UnfoldingGuidance -> Bool

+ GHC.Core: noUnfolding :: Unfolding

+ GHC.Core: notOrphan :: IsOrphan -> Bool

+ GHC.Core: otherCons :: Unfolding -> [AltCon]

+ GHC.Core: rhssOfAlts :: [Alt b] -> [Expr b]

+ GHC.Core: rhssOfBind :: Bind b -> [Expr b]

+ GHC.Core: ruleActivation :: CoreRule -> Activation

+ GHC.Core: ruleArity :: CoreRule -> Int

+ GHC.Core: ruleIdName :: CoreRule -> Name

+ GHC.Core: ruleModule :: CoreRule -> Maybe Module

+ GHC.Core: ruleName :: CoreRule -> RuleName

+ GHC.Core: setRuleIdName :: Name -> CoreRule -> CoreRule

+ GHC.Core: stripNArgs :: Word -> Expr a -> Maybe (Expr a)

+ GHC.Core: tickishCanSplit :: Tickish id -> Bool

+ GHC.Core: tickishContains :: Eq b => Tickish b -> Tickish b -> Bool

+ GHC.Core: tickishCounts :: Tickish id -> Bool

+ GHC.Core: tickishFloatable :: Tickish id -> Bool

+ GHC.Core: tickishIsCode :: Tickish id -> Bool

+ GHC.Core: tickishPlace :: Tickish id -> TickishPlacement

+ GHC.Core: tickishScoped :: Tickish id -> TickishScoping

+ GHC.Core: tickishScopesLike :: Tickish id -> TickishScoping -> Bool

+ GHC.Core: type Alt b = (AltCon, [b], Expr b)

+ GHC.Core: type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)

+ GHC.Core: type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)

+ GHC.Core: type Arg b = Expr b

+ GHC.Core: type CoreAlt = Alt CoreBndr

+ GHC.Core: type CoreArg = Arg CoreBndr

+ GHC.Core: type CoreBind = Bind CoreBndr

+ GHC.Core: type CoreBndr = Var

+ GHC.Core: type CoreExpr = Expr CoreBndr

+ GHC.Core: type CoreProgram = [CoreBind]

+ GHC.Core: type IdUnfoldingFun = Id -> Unfolding

+ GHC.Core: type InAlt = CoreAlt

+ GHC.Core: type InArg = CoreArg

+ GHC.Core: type InBind = CoreBind

+ GHC.Core: type InBndr = CoreBndr

+ GHC.Core: type InCoVar = CoVar

+ GHC.Core: type InCoercion = Coercion

+ GHC.Core: type InExpr = CoreExpr

+ GHC.Core: type InId = Id

+ GHC.Core: type InKind = Kind

+ GHC.Core: type InScopeEnv = (InScopeSet, IdUnfoldingFun)

+ GHC.Core: type InTyVar = TyVar

+ GHC.Core: type InType = Type

+ GHC.Core: type InVar = Var

+ GHC.Core: type MOutCoercion = MCoercion

+ GHC.Core: type OutAlt = CoreAlt

+ GHC.Core: type OutArg = CoreArg

+ GHC.Core: type OutBind = CoreBind

+ GHC.Core: type OutBndr = CoreBndr

+ GHC.Core: type OutCoVar = CoVar

+ GHC.Core: type OutCoercion = Coercion

+ GHC.Core: type OutExpr = CoreExpr

+ GHC.Core: type OutId = Id

+ GHC.Core: type OutKind = Kind

+ GHC.Core: type OutTyVar = TyVar

+ GHC.Core: type OutType = Type

+ GHC.Core: type OutVar = Var

+ GHC.Core: type RuleBase = NameEnv [CoreRule]

+ GHC.Core: type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr

+ GHC.Core: type RuleName = FastString

+ GHC.Core: type TaggedAlt t = Alt (TaggedBndr t)

+ GHC.Core: type TaggedArg t = Arg (TaggedBndr t)

+ GHC.Core: type TaggedBind t = Bind (TaggedBndr t)

+ GHC.Core: type TaggedExpr t = Expr (TaggedBndr t)

+ GHC.Core: unSaturatedOk :: Bool

+ GHC.Core: unfoldingTemplate :: Unfolding -> CoreExpr

+ GHC.Core: valArgCount :: [Arg b] -> Int

+ GHC.Core: valBndrCount :: [CoreBndr] -> Int

+ GHC.Core: varToCoreExpr :: CoreBndr -> Expr b

+ GHC.Core: varsToCoreExprs :: [CoreBndr] -> [Expr b]

+ GHC.Core.Arity: etaExpand :: Arity -> CoreExpr -> CoreExpr

+ GHC.Core.Arity: etaExpandToJoinPoint :: JoinArity -> CoreExpr -> ([CoreBndr], CoreExpr)

+ GHC.Core.Arity: etaExpandToJoinPointRule :: JoinArity -> CoreRule -> CoreRule

+ GHC.Core.Arity: exprArity :: CoreExpr -> Arity

+ GHC.Core.Arity: exprBotStrictness_maybe :: CoreExpr -> Maybe (Arity, StrictSig)

+ GHC.Core.Arity: exprEtaExpandArity :: DynFlags -> CoreExpr -> Arity

+ GHC.Core.Arity: findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> (Arity, Bool)

+ GHC.Core.Arity: instance Outputable.Outputable GHC.Core.Arity.ArityType

+ GHC.Core.Arity: instance Outputable.Outputable GHC.Core.Arity.EtaInfo

+ GHC.Core.Arity: joinRhsArity :: CoreExpr -> JoinArity

+ GHC.Core.Arity: manifestArity :: CoreExpr -> Arity

+ GHC.Core.Arity: typeArity :: Type -> [OneShotInfo]

+ GHC.Core.FVs: bindFreeVars :: CoreBind -> VarSet

+ GHC.Core.FVs: bndrRuleAndUnfoldingVarsDSet :: Id -> DVarSet

+ GHC.Core.FVs: dIdFreeVars :: Id -> DVarSet

+ GHC.Core.FVs: exprFreeIds :: CoreExpr -> IdSet

+ GHC.Core.FVs: exprFreeIdsDSet :: CoreExpr -> DIdSet

+ GHC.Core.FVs: exprFreeIdsList :: CoreExpr -> [Id]

+ GHC.Core.FVs: exprFreeVars :: CoreExpr -> VarSet

+ GHC.Core.FVs: exprFreeVarsDSet :: CoreExpr -> DVarSet

+ GHC.Core.FVs: exprFreeVarsList :: CoreExpr -> [Var]

+ GHC.Core.FVs: exprSomeFreeVars :: InterestingVarFun -> CoreExpr -> VarSet

+ GHC.Core.FVs: exprSomeFreeVarsList :: InterestingVarFun -> CoreExpr -> [Var]

+ GHC.Core.FVs: expr_fvs :: CoreExpr -> FV

+ GHC.Core.FVs: exprsFreeIdsDSet :: [CoreExpr] -> DIdSet

+ GHC.Core.FVs: exprsFreeIdsList :: [CoreExpr] -> [Id]

+ GHC.Core.FVs: exprsFreeVars :: [CoreExpr] -> VarSet

+ GHC.Core.FVs: exprsFreeVarsList :: [CoreExpr] -> [Var]

+ GHC.Core.FVs: exprsOrphNames :: [CoreExpr] -> NameSet

+ GHC.Core.FVs: exprsSomeFreeVars :: InterestingVarFun -> [CoreExpr] -> VarSet

+ GHC.Core.FVs: exprsSomeFreeVarsList :: InterestingVarFun -> [CoreExpr] -> [Var]

+ GHC.Core.FVs: freeVars :: CoreExpr -> CoreExprWithFVs

+ GHC.Core.FVs: freeVarsBind :: CoreBind -> DVarSet -> (CoreBindWithFVs, DVarSet)

+ GHC.Core.FVs: freeVarsOf :: CoreExprWithFVs -> DIdSet

+ GHC.Core.FVs: freeVarsOfAnn :: FVAnn -> DIdSet

+ GHC.Core.FVs: idFVs :: Id -> FV

+ GHC.Core.FVs: idFreeVars :: Id -> VarSet

+ GHC.Core.FVs: idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet

+ GHC.Core.FVs: idRuleVars :: Id -> VarSet

+ GHC.Core.FVs: idUnfoldingVars :: Id -> VarSet

+ GHC.Core.FVs: orphNamesOfAxiom :: CoAxiom br -> NameSet

+ GHC.Core.FVs: orphNamesOfCo :: Coercion -> NameSet

+ GHC.Core.FVs: orphNamesOfCoCon :: CoAxiom br -> NameSet

+ GHC.Core.FVs: orphNamesOfFamInst :: FamInst -> NameSet

+ GHC.Core.FVs: orphNamesOfType :: Type -> NameSet

+ GHC.Core.FVs: orphNamesOfTypes :: [Type] -> NameSet

+ GHC.Core.FVs: ruleFreeVars :: CoreRule -> VarSet

+ GHC.Core.FVs: ruleLhsFreeIds :: CoreRule -> VarSet

+ GHC.Core.FVs: ruleLhsFreeIdsList :: CoreRule -> [Var]

+ GHC.Core.FVs: ruleRhsFreeVars :: CoreRule -> VarSet

+ GHC.Core.FVs: rulesFreeVars :: [CoreRule] -> VarSet

+ GHC.Core.FVs: rulesFreeVarsDSet :: [CoreRule] -> DVarSet

+ GHC.Core.FVs: stableUnfoldingVars :: Unfolding -> Maybe VarSet

+ GHC.Core.FVs: type CoreAltWithFVs = AnnAlt Id FVAnn

+ GHC.Core.FVs: type CoreBindWithFVs = AnnBind Id FVAnn

+ GHC.Core.FVs: type CoreExprWithFVs = AnnExpr Id FVAnn

+ GHC.Core.FVs: type CoreExprWithFVs' = AnnExpr' Id FVAnn

+ GHC.Core.FVs: type FVAnn = DVarSet

+ GHC.Core.FVs: type InterestingVarFun = Var -> Bool

+ GHC.Core.FVs: varTypeTyCoFVs :: Var -> FV

+ GHC.Core.FVs: varTypeTyCoVars :: Var -> TyCoVarSet

+ GHC.Core.Make: FloatCase :: CoreExpr -> Id -> AltCon -> [Var] -> FloatBind

+ GHC.Core.Make: FloatLet :: CoreBind -> FloatBind

+ GHC.Core.Make: aBSENT_ERROR_ID :: Id

+ GHC.Core.Make: aBSENT_SUM_FIELD_ERROR_ID :: Id

+ GHC.Core.Make: castBottomExpr :: CoreExpr -> Type -> CoreExpr

+ GHC.Core.Make: data FloatBind

+ GHC.Core.Make: errorIds :: [Id]

+ GHC.Core.Make: floatBindings :: FloatBind -> [Var]

+ GHC.Core.Make: infixl 4 `mkCoreApps`

+ GHC.Core.Make: instance Outputable.Outputable GHC.Core.Make.FloatBind

+ GHC.Core.Make: mkAbsentErrorApp :: Type -> String -> CoreExpr

+ GHC.Core.Make: mkBigCoreTup :: [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkBigCoreTupTy :: [Type] -> Type

+ GHC.Core.Make: mkBigCoreVarTup :: [Id] -> CoreExpr

+ GHC.Core.Make: mkBigCoreVarTup1 :: [Id] -> CoreExpr

+ GHC.Core.Make: mkBigCoreVarTupTy :: [Id] -> Type

+ GHC.Core.Make: mkBuildExpr :: (MonadFail m, MonadThings m, MonadUnique m) => Type -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -> m CoreExpr

+ GHC.Core.Make: mkCharExpr :: Char -> CoreExpr

+ GHC.Core.Make: mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkCoreTup :: [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkCoreVarTupTy :: [Id] -> Type

+ GHC.Core.Make: mkDoubleExpr :: Double -> CoreExpr

+ GHC.Core.Make: mkFloatExpr :: Float -> CoreExpr

+ GHC.Core.Make: mkFoldrExpr :: MonadThings m => Type -> Type -> CoreExpr -> CoreExpr -> CoreExpr -> m CoreExpr

+ GHC.Core.Make: mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkImpossibleExpr :: Type -> CoreExpr

+ GHC.Core.Make: mkIntExpr :: DynFlags -> Integer -> CoreExpr

+ GHC.Core.Make: mkIntExprInt :: DynFlags -> Int -> CoreExpr

+ GHC.Core.Make: mkIntegerExpr :: MonadThings m => Integer -> m CoreExpr

+ GHC.Core.Make: mkJustExpr :: Type -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkListExpr :: Type -> [CoreExpr] -> CoreExpr

+ GHC.Core.Make: mkNaturalExpr :: MonadThings m => Integer -> m CoreExpr

+ GHC.Core.Make: mkNilExpr :: Type -> CoreExpr

+ GHC.Core.Make: mkNothingExpr :: Type -> CoreExpr

+ GHC.Core.Make: mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr

+ GHC.Core.Make: mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkSmallTupleCase :: [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkSmallTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkStringExpr :: MonadThings m => String -> m CoreExpr

+ GHC.Core.Make: mkStringExprFS :: MonadThings m => FastString -> m CoreExpr

+ GHC.Core.Make: mkStringExprFSWith :: Monad m => (Name -> m Id) -> FastString -> m CoreExpr

+ GHC.Core.Make: mkTupleCase :: UniqSupply -> [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkTupleSelector1 :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr

+ GHC.Core.Make: mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr

+ GHC.Core.Make: mkWildEvBinder :: PredType -> EvVar

+ GHC.Core.Make: mkWildValBinder :: Type -> Id

+ GHC.Core.Make: mkWordExpr :: DynFlags -> Integer -> CoreExpr

+ GHC.Core.Make: mkWordExprWord :: DynFlags -> Word -> CoreExpr

+ GHC.Core.Make: nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id

+ GHC.Core.Make: nO_METHOD_BINDING_ERROR_ID :: Id

+ GHC.Core.Make: pAT_ERROR_ID :: Id

+ GHC.Core.Make: rEC_CON_ERROR_ID :: Id

+ GHC.Core.Make: rEC_SEL_ERROR_ID :: Id

+ GHC.Core.Make: rUNTIME_ERROR_ID :: Id

+ GHC.Core.Make: sortQuantVars :: [Var] -> [Var]

+ GHC.Core.Make: tYPE_ERROR_ID :: Id

+ GHC.Core.Make: unitExpr :: CoreExpr

+ GHC.Core.Make: wrapFloat :: FloatBind -> CoreExpr -> CoreExpr

+ GHC.Core.Make: wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr

+ GHC.Core.Map: (>.>) :: (a -> b) -> (b -> c) -> a -> c

+ GHC.Core.Map: (|>) :: a -> (a -> b) -> b

+ GHC.Core.Map: (|>>) :: TrieMap m2 => (XT (m2 a) -> m1 (m2 a) -> m1 (m2 a)) -> (m2 a -> m2 a) -> m1 (m2 a) -> m1 (m2 a)

+ GHC.Core.Map: alterTM :: forall b. TrieMap m => Key m -> XT b -> m b -> m b

+ GHC.Core.Map: class TrieMap m where {

+ GHC.Core.Map: data CmEnv

+ GHC.Core.Map: data CoreMap a

+ GHC.Core.Map: data GenMap m a

+ GHC.Core.Map: data ListMap m a

+ GHC.Core.Map: data LooseTypeMap a

+ GHC.Core.Map: data MaybeMap m a

+ GHC.Core.Map: data TypeMap a

+ GHC.Core.Map: deleteTM :: TrieMap m => Key m -> m a -> m a

+ GHC.Core.Map: emptyCoreMap :: CoreMap a

+ GHC.Core.Map: emptyTM :: TrieMap m => m a

+ GHC.Core.Map: emptyTypeMap :: TypeMap a

+ GHC.Core.Map: extendCoreMap :: CoreMap a -> CoreExpr -> a -> CoreMap a

+ GHC.Core.Map: extendTypeMap :: TypeMap a -> Type -> a -> TypeMap a

+ GHC.Core.Map: extendTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> a -> TypeMap a

+ GHC.Core.Map: foldCoreMap :: (a -> b -> b) -> b -> CoreMap a -> b

+ GHC.Core.Map: foldTM :: TrieMap m => (a -> b -> b) -> m a -> b -> b

+ GHC.Core.Map: foldTypeMap :: (a -> b -> b) -> b -> TypeMap a -> b

+ GHC.Core.Map: infixr 1 |>>

+ GHC.Core.Map: insertTM :: TrieMap m => Key m -> a -> m a -> m a

+ GHC.Core.Map: instance GHC.Classes.Eq (GHC.Core.Map.DeBruijn GHC.Core.CoreAlt)

+ GHC.Core.Map: instance GHC.Classes.Eq (GHC.Core.Map.DeBruijn GHC.Core.CoreExpr)

+ GHC.Core.Map: instance GHC.Classes.Eq (GHC.Core.Map.DeBruijn TyCoRep.Coercion)

+ GHC.Core.Map: instance GHC.Classes.Eq (GHC.Core.Map.DeBruijn TyCoRep.Type)

+ GHC.Core.Map: instance GHC.Classes.Eq (GHC.Core.Map.DeBruijn a) => GHC.Classes.Eq (GHC.Core.Map.DeBruijn [a])

+ GHC.Core.Map: instance Outputable.Outputable a => Outputable.Outputable (GHC.Core.Map.CoreMap a)

+ GHC.Core.Map: instance Outputable.Outputable a => Outputable.Outputable (GHC.Core.Map.TypeMapG a)

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.AltMap

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.CoercionMap

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.CoercionMapX

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.CoreMap

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.CoreMapX

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.LooseTypeMap

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.TyLitMap

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.TypeMap

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.TypeMapX

+ GHC.Core.Map: instance TrieMap.TrieMap GHC.Core.Map.VarMap

+ GHC.Core.Map: lkDFreeVar :: Var -> DVarEnv a -> Maybe a

+ GHC.Core.Map: lkDNamed :: NamedThing n => n -> DNameEnv a -> Maybe a

+ GHC.Core.Map: lookupCME :: CmEnv -> Var -> Maybe BoundVar

+ GHC.Core.Map: lookupCoreMap :: CoreMap a -> CoreExpr -> Maybe a

+ GHC.Core.Map: lookupTM :: forall b. TrieMap m => Key m -> m b -> Maybe b

+ GHC.Core.Map: lookupTypeMap :: TypeMap a -> Type -> Maybe a

+ GHC.Core.Map: lookupTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> Maybe a

+ GHC.Core.Map: mapTM :: TrieMap m => (a -> b) -> m a -> m b

+ GHC.Core.Map: mkDeBruijnContext :: [Var] -> CmEnv

+ GHC.Core.Map: type LiteralMap a = Map Literal a

+ GHC.Core.Map: type family Key m :: Type;

+ GHC.Core.Map: xtDFreeVar :: Var -> XT a -> DVarEnv a -> DVarEnv a

+ GHC.Core.Map: xtDNamed :: NamedThing n => n -> XT a -> DNameEnv a -> DNameEnv a

+ GHC.Core.Map: }

+ GHC.Core.Op.Tidy: tidyExpr :: TidyEnv -> CoreExpr -> CoreExpr

+ GHC.Core.Op.Tidy: tidyRules :: TidyEnv -> [CoreRule] -> [CoreRule]

+ GHC.Core.Op.Tidy: tidyUnfolding :: TidyEnv -> Unfolding -> Unfolding -> Unfolding

+ GHC.Core.Ppr: instance Outputable.Outputable GHC.Core.CoreRule

+ GHC.Core.Ppr: instance Outputable.Outputable GHC.Core.Unfolding

+ GHC.Core.Ppr: instance Outputable.Outputable GHC.Core.UnfoldingGuidance

+ GHC.Core.Ppr: instance Outputable.Outputable GHC.Core.UnfoldingSource

+ GHC.Core.Ppr: instance Outputable.Outputable IdInfo.IdInfo

+ GHC.Core.Ppr: instance Outputable.Outputable b => Outputable.OutputableBndr (GHC.Core.TaggedBndr b)

+ GHC.Core.Ppr: instance Outputable.Outputable id => Outputable.Outputable (GHC.Core.Tickish id)

+ GHC.Core.Ppr: instance Outputable.OutputableBndr Var.Var

+ GHC.Core.Ppr: instance Outputable.OutputableBndr b => Outputable.Outputable (GHC.Core.Bind b)

+ GHC.Core.Ppr: instance Outputable.OutputableBndr b => Outputable.Outputable (GHC.Core.Expr b)

+ GHC.Core.Ppr: pprCoreAlt :: OutputableBndr a => (AltCon, [a], Expr a) -> SDoc

+ GHC.Core.Ppr: pprCoreBinding :: OutputableBndr b => Bind b -> SDoc

+ GHC.Core.Ppr: pprCoreBindingWithSize :: CoreBind -> SDoc

+ GHC.Core.Ppr: pprCoreBindings :: OutputableBndr b => [Bind b] -> SDoc

+ GHC.Core.Ppr: pprCoreBindingsWithSize :: [CoreBind] -> SDoc

+ GHC.Core.Ppr: pprCoreExpr :: OutputableBndr b => Expr b -> SDoc

+ GHC.Core.Ppr: pprOptCo :: Coercion -> SDoc

+ GHC.Core.Ppr: pprParendExpr :: OutputableBndr b => Expr b -> SDoc

+ GHC.Core.Ppr: pprRules :: [CoreRule] -> SDoc

+ GHC.Core.Rules: addIdSpecialisations :: Id -> [CoreRule] -> Id

+ GHC.Core.Rules: addRuleInfo :: RuleInfo -> RuleInfo -> RuleInfo

+ GHC.Core.Rules: emptyRuleBase :: RuleBase

+ GHC.Core.Rules: extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase

+ GHC.Core.Rules: extendRuleInfo :: RuleInfo -> [CoreRule] -> RuleInfo

+ GHC.Core.Rules: getRules :: RuleEnv -> Id -> [CoreRule]

+ GHC.Core.Rules: lookupRule :: DynFlags -> InScopeEnv -> (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr)

+ GHC.Core.Rules: mkRule :: Module -> Bool -> Bool -> RuleName -> Activation -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule

+ GHC.Core.Rules: mkRuleBase :: [CoreRule] -> RuleBase

+ GHC.Core.Rules: mkRuleInfo :: [CoreRule] -> RuleInfo

+ GHC.Core.Rules: pprRuleBase :: RuleBase -> SDoc

+ GHC.Core.Rules: pprRulesForUser :: DynFlags -> [CoreRule] -> SDoc

+ GHC.Core.Rules: roughTopNames :: [CoreExpr] -> [Maybe Name]

+ GHC.Core.Rules: ruleCheckProgram :: CompilerPhase -> String -> (Id -> [CoreRule]) -> CoreProgram -> SDoc

+ GHC.Core.Rules: rulesOfBinds :: [CoreBind] -> [CoreRule]

+ GHC.Core.Rules: unionRuleBase :: RuleBase -> RuleBase -> RuleBase

+ GHC.Core.Seq: megaSeqIdInfo :: IdInfo -> ()

+ GHC.Core.Seq: seqBinds :: [Bind CoreBndr] -> ()

+ GHC.Core.Seq: seqExpr :: CoreExpr -> ()

+ GHC.Core.Seq: seqExprs :: [CoreExpr] -> ()

+ GHC.Core.Seq: seqRuleInfo :: RuleInfo -> ()

+ GHC.Core.Seq: seqRules :: [CoreRule] -> ()

+ GHC.Core.Seq: seqUnfolding :: Unfolding -> ()

+ GHC.Core.SimpleOpt: collectBindersPushingCo :: CoreExpr -> ([Var], CoreExpr)

+ GHC.Core.SimpleOpt: exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])

+ GHC.Core.SimpleOpt: exprIsLambda_maybe :: InScopeEnv -> CoreExpr -> Maybe (Var, CoreExpr, [Tickish Id])

+ GHC.Core.SimpleOpt: exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal

+ GHC.Core.SimpleOpt: instance Outputable.Outputable GHC.Core.SimpleOpt.SimpleOptEnv

+ GHC.Core.SimpleOpt: joinPointBinding_maybe :: InBndr -> InExpr -> Maybe (InBndr, InExpr)

+ GHC.Core.SimpleOpt: joinPointBindings_maybe :: [(InBndr, InExpr)] -> Maybe [(InBndr, InExpr)]

+ GHC.Core.SimpleOpt: pushCoArg :: CoercionR -> CoreArg -> Maybe (CoreArg, MCoercion)

+ GHC.Core.SimpleOpt: pushCoTyArg :: CoercionR -> Type -> Maybe (Type, MCoercionR)

+ GHC.Core.SimpleOpt: pushCoValArg :: CoercionR -> Maybe (Coercion, MCoercion)

+ GHC.Core.SimpleOpt: simpleOptExpr :: DynFlags -> CoreExpr -> CoreExpr

+ GHC.Core.SimpleOpt: simpleOptExprWith :: DynFlags -> Subst -> InExpr -> OutExpr

+ GHC.Core.SimpleOpt: simpleOptPgm :: DynFlags -> Module -> CoreProgram -> [CoreRule] -> IO (CoreProgram, [CoreRule])

+ GHC.Core.Stats: CS :: !Int -> !Int -> !Int -> !Int -> !Int -> CoreStats

+ GHC.Core.Stats: [cs_co] :: CoreStats -> !Int

+ GHC.Core.Stats: [cs_jb] :: CoreStats -> !Int

+ GHC.Core.Stats: [cs_tm] :: CoreStats -> !Int

+ GHC.Core.Stats: [cs_ty] :: CoreStats -> !Int

+ GHC.Core.Stats: [cs_vb] :: CoreStats -> !Int

+ GHC.Core.Stats: coreBindsSize :: [CoreBind] -> Int

+ GHC.Core.Stats: coreBindsStats :: [CoreBind] -> CoreStats

+ GHC.Core.Stats: data CoreStats

+ GHC.Core.Stats: exprSize :: CoreExpr -> Int

+ GHC.Core.Stats: exprStats :: CoreExpr -> CoreStats

+ GHC.Core.Stats: instance Outputable.Outputable GHC.Core.Stats.CoreStats

+ GHC.Core.Subst: Subst :: InScopeSet -> IdSubstEnv -> TvSubstEnv -> CvSubstEnv -> Subst

+ GHC.Core.Subst: addInScopeSet :: Subst -> VarSet -> Subst

+ GHC.Core.Subst: cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)

+ GHC.Core.Subst: cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])

+ GHC.Core.Subst: cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)

+ GHC.Core.Subst: cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

+ GHC.Core.Subst: cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

+ GHC.Core.Subst: data InScopeSet

+ GHC.Core.Subst: data Subst

+ GHC.Core.Subst: deShadowBinds :: CoreProgram -> CoreProgram

+ GHC.Core.Subst: delBndr :: Subst -> Var -> Subst

+ GHC.Core.Subst: delBndrs :: Subst -> [Var] -> Subst

+ GHC.Core.Subst: emptySubst :: Subst

+ GHC.Core.Subst: extendCvSubst :: Subst -> CoVar -> Coercion -> Subst

+ GHC.Core.Subst: extendIdSubst :: Subst -> Id -> CoreExpr -> Subst

+ GHC.Core.Subst: extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst

+ GHC.Core.Subst: extendInScope :: Subst -> Var -> Subst

+ GHC.Core.Subst: extendInScopeIds :: Subst -> [Id] -> Subst

+ GHC.Core.Subst: extendInScopeList :: Subst -> [Var] -> Subst

+ GHC.Core.Subst: extendSubst :: Subst -> Var -> CoreArg -> Subst

+ GHC.Core.Subst: extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst

+ GHC.Core.Subst: extendSubstWithVar :: Subst -> Var -> Var -> Subst

+ GHC.Core.Subst: extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst

+ GHC.Core.Subst: extendTvSubst :: Subst -> TyVar -> Type -> Subst

+ GHC.Core.Subst: extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst

+ GHC.Core.Subst: getTCvSubst :: Subst -> TCvSubst

+ GHC.Core.Subst: instance Outputable.Outputable GHC.Core.Subst.Subst

+ GHC.Core.Subst: isEmptySubst :: Subst -> Bool

+ GHC.Core.Subst: isInScope :: Var -> Subst -> Bool

+ GHC.Core.Subst: lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr

+ GHC.Core.Subst: lookupTCvSubst :: Subst -> TyVar -> Type

+ GHC.Core.Subst: mkEmptySubst :: InScopeSet -> Subst

+ GHC.Core.Subst: mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst

+ GHC.Core.Subst: mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst

+ GHC.Core.Subst: setInScope :: Subst -> InScopeSet -> Subst

+ GHC.Core.Subst: substBind :: Subst -> CoreBind -> (Subst, CoreBind)

+ GHC.Core.Subst: substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)

+ GHC.Core.Subst: substBndr :: Subst -> Var -> (Subst, Var)

+ GHC.Core.Subst: substBndrs :: Subst -> [Var] -> (Subst, [Var])

+ GHC.Core.Subst: substCo :: HasCallStack => Subst -> Coercion -> Coercion

+ GHC.Core.Subst: substCoVarBndr :: Subst -> TyVar -> (Subst, TyVar)

+ GHC.Core.Subst: substDVarSet :: Subst -> DVarSet -> DVarSet

+ GHC.Core.Subst: substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr

+ GHC.Core.Subst: substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr

+ GHC.Core.Subst: substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo

+ GHC.Core.Subst: substIdOcc :: Subst -> Id -> Id

+ GHC.Core.Subst: substInScope :: Subst -> InScopeSet

+ GHC.Core.Subst: substRecBndrs :: Subst -> [Id] -> (Subst, [Id])

+ GHC.Core.Subst: substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]

+ GHC.Core.Subst: substSpec :: Subst -> Id -> RuleInfo -> RuleInfo

+ GHC.Core.Subst: substTickish :: Subst -> Tickish Id -> Tickish Id

+ GHC.Core.Subst: substTy :: Subst -> Type -> Type

+ GHC.Core.Subst: substTyVarBndr :: Subst -> TyVar -> (Subst, TyVar)

+ GHC.Core.Subst: substUnfolding :: Subst -> Unfolding -> Unfolding

+ GHC.Core.Subst: substUnfoldingSC :: Subst -> Unfolding -> Unfolding

+ GHC.Core.Subst: type IdSubstEnv = IdEnv CoreExpr

+ GHC.Core.Subst: type TvSubstEnv = TyVarEnv Type

+ GHC.Core.Subst: zapSubstEnv :: Subst -> Subst

+ GHC.Core.Unfold: BoringCtxt :: CallCtxt

+ GHC.Core.Unfold: CaseCtxt :: CallCtxt

+ GHC.Core.Unfold: DiscArgCtxt :: CallCtxt

+ GHC.Core.Unfold: NonTrivArg :: ArgSummary

+ GHC.Core.Unfold: RhsCtxt :: CallCtxt

+ GHC.Core.Unfold: RuleArgCtxt :: CallCtxt

+ GHC.Core.Unfold: TrivArg :: ArgSummary

+ GHC.Core.Unfold: ValAppCtxt :: CallCtxt

+ GHC.Core.Unfold: ValueArg :: ArgSummary

+ GHC.Core.Unfold: callSiteInline :: DynFlags -> Id -> Bool -> Bool -> [ArgSummary] -> CallCtxt -> Maybe CoreExpr

+ GHC.Core.Unfold: certainlyWillInline :: DynFlags -> IdInfo -> Maybe Unfolding

+ GHC.Core.Unfold: couldBeSmallEnoughToInline :: DynFlags -> Int -> CoreExpr -> Bool

+ GHC.Core.Unfold: data ArgSummary

+ GHC.Core.Unfold: data CallCtxt

+ GHC.Core.Unfold: data Unfolding

+ GHC.Core.Unfold: data UnfoldingGuidance

+ GHC.Core.Unfold: exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])

+ GHC.Core.Unfold: exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal

+ GHC.Core.Unfold: inlineBoringOk :: CoreExpr -> Bool

+ GHC.Core.Unfold: instance Outputable.Outputable GHC.Core.Unfold.ArgSummary

+ GHC.Core.Unfold: instance Outputable.Outputable GHC.Core.Unfold.CallCtxt

+ GHC.Core.Unfold: instance Outputable.Outputable GHC.Core.Unfold.ExprSize

+ GHC.Core.Unfold: mkCompulsoryUnfolding :: CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkCoreUnfolding :: UnfoldingSource -> Bool -> CoreExpr -> UnfoldingGuidance -> Unfolding

+ GHC.Core.Unfold: mkDFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding

+ GHC.Core.Unfold: mkImplicitUnfolding :: DynFlags -> CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkInlinableUnfolding :: DynFlags -> CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkInlineUnfolding :: CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkInlineUnfoldingWithArity :: Arity -> CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkSimpleUnfolding :: DynFlags -> CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkTopUnfolding :: DynFlags -> Bool -> CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkUnfolding :: DynFlags -> UnfoldingSource -> Bool -> Bool -> CoreExpr -> Unfolding

+ GHC.Core.Unfold: mkWorkerUnfolding :: DynFlags -> (CoreExpr -> CoreExpr) -> Unfolding -> Unfolding

+ GHC.Core.Unfold: mkWwInlineRule :: DynFlags -> CoreExpr -> Arity -> Unfolding

+ GHC.Core.Unfold: noUnfolding :: Unfolding

+ GHC.Core.Unfold: smallEnoughToInline :: DynFlags -> Unfolding -> Bool

+ GHC.Core.Unfold: specUnfolding :: DynFlags -> [Var] -> (CoreExpr -> CoreExpr) -> Arity -> Unfolding -> Unfolding

+ GHC.Core.Utils: addDefault :: [(AltCon, [a], b)] -> Maybe b -> [(AltCon, [a], b)]

+ GHC.Core.Utils: altsAreExhaustive :: [Alt b] -> Bool

+ GHC.Core.Utils: applyTypeToArg :: Type -> CoreExpr -> Type

+ GHC.Core.Utils: applyTypeToArgs :: CoreExpr -> Type -> [CoreExpr] -> Type

+ GHC.Core.Utils: bindNonRec :: Id -> CoreExpr -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: cheapEqExpr :: Expr b -> Expr b -> Bool

+ GHC.Core.Utils: cheapEqExpr' :: (Tickish Id -> Bool) -> Expr b -> Expr b -> Bool

+ GHC.Core.Utils: collectMakeStaticArgs :: CoreExpr -> Maybe (CoreExpr, Type, CoreExpr, CoreExpr)

+ GHC.Core.Utils: combineIdenticalAlts :: [AltCon] -> [CoreAlt] -> (Bool, [AltCon], [CoreAlt])

+ GHC.Core.Utils: coreAltType :: CoreAlt -> Type

+ GHC.Core.Utils: coreAltsType :: [CoreAlt] -> Type

+ GHC.Core.Utils: dataConRepFSInstPat :: [FastString] -> [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])

+ GHC.Core.Utils: dataConRepInstPat :: [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])

+ GHC.Core.Utils: diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)] -> ([SDoc], RnEnv2)

+ GHC.Core.Utils: diffExpr :: Bool -> RnEnv2 -> CoreExpr -> CoreExpr -> [SDoc]

+ GHC.Core.Utils: dumpIdInfoOfProgram :: (IdInfo -> SDoc) -> CoreProgram -> SDoc

+ GHC.Core.Utils: eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool

+ GHC.Core.Utils: exprIsBig :: Expr b -> Bool

+ GHC.Core.Utils: exprIsBottom :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsCheap :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool

+ GHC.Core.Utils: exprIsConLike :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsDupable :: DynFlags -> CoreExpr -> Bool

+ GHC.Core.Utils: exprIsExpandable :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsHNF :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsTickedString :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsTickedString_maybe :: CoreExpr -> Maybe ByteString

+ GHC.Core.Utils: exprIsTopLevelBindable :: CoreExpr -> Type -> Bool

+ GHC.Core.Utils: exprIsTrivial :: CoreExpr -> Bool

+ GHC.Core.Utils: exprIsWorkFree :: CoreExpr -> Bool

+ GHC.Core.Utils: exprOkForSideEffects :: CoreExpr -> Bool

+ GHC.Core.Utils: exprOkForSpeculation :: CoreExpr -> Bool

+ GHC.Core.Utils: exprToCoercion_maybe :: CoreExpr -> Maybe Coercion

+ GHC.Core.Utils: exprToType :: CoreExpr -> Type

+ GHC.Core.Utils: exprType :: CoreExpr -> Type

+ GHC.Core.Utils: filterAlts :: TyCon -> [Type] -> [AltCon] -> [(AltCon, [Var], a)] -> ([AltCon], [(AltCon, [Var], a)])

+ GHC.Core.Utils: findAlt :: AltCon -> [(AltCon, a, b)] -> Maybe (AltCon, a, b)

+ GHC.Core.Utils: findDefault :: [(AltCon, [a], b)] -> ([(AltCon, [a], b)], Maybe b)

+ GHC.Core.Utils: getIdFromTrivialExpr :: HasDebugCallStack => CoreExpr -> Id

+ GHC.Core.Utils: getIdFromTrivialExpr_maybe :: CoreExpr -> Maybe Id

+ GHC.Core.Utils: isCheapApp :: CheapAppFun

+ GHC.Core.Utils: isDefaultAlt :: (AltCon, a, b) -> Bool

+ GHC.Core.Utils: isEmptyTy :: Type -> Bool

+ GHC.Core.Utils: isExpandableApp :: CheapAppFun

+ GHC.Core.Utils: isExprLevPoly :: CoreExpr -> Bool

+ GHC.Core.Utils: isJoinBind :: CoreBind -> Bool

+ GHC.Core.Utils: mergeAlts :: [(AltCon, a, b)] -> [(AltCon, a, b)] -> [(AltCon, a, b)]

+ GHC.Core.Utils: mkAltExpr :: AltCon -> [CoreBndr] -> [Type] -> CoreExpr

+ GHC.Core.Utils: mkCast :: CoreExpr -> CoercionR -> CoreExpr

+ GHC.Core.Utils: mkDefaultCase :: CoreExpr -> Id -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: mkTick :: Tickish Id -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: mkTickNoHNF :: Tickish Id -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: mkTicks :: [Tickish Id] -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: needsCaseBinding :: Type -> CoreExpr -> Bool

+ GHC.Core.Utils: refineDefaultAlt :: [Unique] -> TyCon -> [Type] -> [AltCon] -> [CoreAlt] -> (Bool, [CoreAlt])

+ GHC.Core.Utils: stripTicksE :: (Tickish Id -> Bool) -> Expr b -> Expr b

+ GHC.Core.Utils: stripTicksT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]

+ GHC.Core.Utils: stripTicksTop :: (Tickish Id -> Bool) -> Expr b -> ([Tickish Id], Expr b)

+ GHC.Core.Utils: stripTicksTopE :: (Tickish Id -> Bool) -> Expr b -> Expr b

+ GHC.Core.Utils: stripTicksTopT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]

+ GHC.Core.Utils: tickHNFArgs :: Tickish Id -> CoreExpr -> CoreExpr

+ GHC.Core.Utils: trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]

+ GHC.Core.Utils: tryEtaReduce :: [Var] -> CoreExpr -> Maybe CoreExpr

+ GHC.Core.Utils: type CheapAppFun = Id -> Arity -> Bool

+ GHC.Driver.Backpack.Syntax: DeclD :: HscSource -> Located ModuleName -> Maybe (Located HsModule) -> HsUnitDecl n

+ GHC.Driver.Backpack.Syntax: HsComponentId :: PackageName -> ComponentId -> HsComponentId

+ GHC.Driver.Backpack.Syntax: HsModuleId :: LHsUnitId n -> Located ModuleName -> HsModuleId n

+ GHC.Driver.Backpack.Syntax: HsModuleVar :: Located ModuleName -> HsModuleId n

+ GHC.Driver.Backpack.Syntax: HsUnit :: Located n -> [LHsUnitDecl n] -> HsUnit n

+ GHC.Driver.Backpack.Syntax: HsUnitId :: Located n -> [LHsModuleSubst n] -> HsUnitId n

+ GHC.Driver.Backpack.Syntax: IncludeD :: IncludeDecl n -> HsUnitDecl n

+ GHC.Driver.Backpack.Syntax: IncludeDecl :: LHsUnitId n -> Maybe [LRenaming] -> Bool -> IncludeDecl n

+ GHC.Driver.Backpack.Syntax: Renaming :: Located ModuleName -> Maybe (Located ModuleName) -> Renaming

+ GHC.Driver.Backpack.Syntax: [hsComponentId] :: HsComponentId -> ComponentId

+ GHC.Driver.Backpack.Syntax: [hsPackageName] :: HsComponentId -> PackageName

+ GHC.Driver.Backpack.Syntax: [hsunitBody] :: HsUnit n -> [LHsUnitDecl n]

+ GHC.Driver.Backpack.Syntax: [hsunitName] :: HsUnit n -> Located n

+ GHC.Driver.Backpack.Syntax: [idModRenaming] :: IncludeDecl n -> Maybe [LRenaming]

+ GHC.Driver.Backpack.Syntax: [idSignatureInclude] :: IncludeDecl n -> Bool

+ GHC.Driver.Backpack.Syntax: [idUnitId] :: IncludeDecl n -> LHsUnitId n

+ GHC.Driver.Backpack.Syntax: [renameFrom] :: Renaming -> Located ModuleName

+ GHC.Driver.Backpack.Syntax: [renameTo] :: Renaming -> Maybe (Located ModuleName)

+ GHC.Driver.Backpack.Syntax: data HsComponentId

+ GHC.Driver.Backpack.Syntax: data HsModuleId n

+ GHC.Driver.Backpack.Syntax: data HsUnit n

+ GHC.Driver.Backpack.Syntax: data HsUnitDecl n

+ GHC.Driver.Backpack.Syntax: data HsUnitId n

+ GHC.Driver.Backpack.Syntax: data IncludeDecl n

+ GHC.Driver.Backpack.Syntax: data Renaming

+ GHC.Driver.Backpack.Syntax: instance Outputable.Outputable GHC.Driver.Backpack.Syntax.HsComponentId

+ GHC.Driver.Backpack.Syntax: type HsModuleSubst n = (Located ModuleName, LHsModuleId n)

+ GHC.Driver.Backpack.Syntax: type LHsModuleId n = Located (HsModuleId n)

+ GHC.Driver.Backpack.Syntax: type LHsModuleSubst n = Located (HsModuleSubst n)

+ GHC.Driver.Backpack.Syntax: type LHsUnit n = Located (HsUnit n)

+ GHC.Driver.Backpack.Syntax: type LHsUnitDecl n = Located (HsUnitDecl n)

+ GHC.Driver.Backpack.Syntax: type LHsUnitId n = Located (HsUnitId n)

+ GHC.Driver.Backpack.Syntax: type LRenaming = Located Renaming

+ GHC.Driver.CmdLine: AllModes :: GhcFlagMode

+ GHC.Driver.CmdLine: AnySuffix :: (String -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: CmdLineP :: (s -> (a, s)) -> CmdLineP s a

+ GHC.Driver.CmdLine: Err :: Located String -> Err

+ GHC.Driver.CmdLine: Flag :: String -> OptKind m -> GhcFlagMode -> Flag m

+ GHC.Driver.CmdLine: FloatSuffix :: (Float -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: HasArg :: (String -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: HiddenFlag :: GhcFlagMode

+ GHC.Driver.CmdLine: IntSuffix :: (Int -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: NoArg :: EwM m () -> OptKind m

+ GHC.Driver.CmdLine: NoReason :: WarnReason

+ GHC.Driver.CmdLine: OnlyGhc :: GhcFlagMode

+ GHC.Driver.CmdLine: OnlyGhci :: GhcFlagMode

+ GHC.Driver.CmdLine: OptIntSuffix :: (Maybe Int -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: OptPrefix :: (String -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: PassFlag :: (String -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: Prefix :: (String -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: ReasonDeprecatedFlag :: WarnReason

+ GHC.Driver.CmdLine: ReasonUnrecognisedFlag :: WarnReason

+ GHC.Driver.CmdLine: SepArg :: (String -> EwM m ()) -> OptKind m

+ GHC.Driver.CmdLine: Warn :: WarnReason -> Located String -> Warn

+ GHC.Driver.CmdLine: [errMsg] :: Err -> Located String

+ GHC.Driver.CmdLine: [flagGhcMode] :: Flag m -> GhcFlagMode

+ GHC.Driver.CmdLine: [flagName] :: Flag m -> String

+ GHC.Driver.CmdLine: [flagOptKind] :: Flag m -> OptKind m

+ GHC.Driver.CmdLine: [runCmdLine] :: CmdLineP s a -> s -> (a, s)

+ GHC.Driver.CmdLine: [warnMsg] :: Warn -> Located String

+ GHC.Driver.CmdLine: [warnReason] :: Warn -> WarnReason

+ GHC.Driver.CmdLine: addErr :: Monad m => String -> EwM m ()

+ GHC.Driver.CmdLine: addFlagWarn :: Monad m => WarnReason -> String -> EwM m ()

+ GHC.Driver.CmdLine: addWarn :: Monad m => String -> EwM m ()

+ GHC.Driver.CmdLine: data EwM m a

+ GHC.Driver.CmdLine: data Flag m

+ GHC.Driver.CmdLine: data GhcFlagMode

+ GHC.Driver.CmdLine: data OptKind m

+ GHC.Driver.CmdLine: data Warn

+ GHC.Driver.CmdLine: data WarnReason

+ GHC.Driver.CmdLine: defFlag :: String -> OptKind m -> Flag m

+ GHC.Driver.CmdLine: defGhcFlag :: String -> OptKind m -> Flag m

+ GHC.Driver.CmdLine: defGhciFlag :: String -> OptKind m -> Flag m

+ GHC.Driver.CmdLine: defHiddenFlag :: String -> OptKind m -> Flag m

+ GHC.Driver.CmdLine: deprecate :: Monad m => String -> EwM m ()

+ GHC.Driver.CmdLine: errorsToGhcException :: [(String, String)] -> GhcException

+ GHC.Driver.CmdLine: getArg :: Monad m => EwM m String

+ GHC.Driver.CmdLine: getCmdLineState :: CmdLineP s s

+ GHC.Driver.CmdLine: getCurLoc :: Monad m => EwM m SrcSpan

+ GHC.Driver.CmdLine: instance GHC.Base.Applicative (GHC.Driver.CmdLine.CmdLineP s)

+ GHC.Driver.CmdLine: instance GHC.Base.Functor (GHC.Driver.CmdLine.CmdLineP s)

+ GHC.Driver.CmdLine: instance GHC.Base.Monad (GHC.Driver.CmdLine.CmdLineP s)

+ GHC.Driver.CmdLine: instance GHC.Base.Monad m => GHC.Base.Applicative (GHC.Driver.CmdLine.EwM m)

+ GHC.Driver.CmdLine: instance GHC.Base.Monad m => GHC.Base.Functor (GHC.Driver.CmdLine.EwM m)

+ GHC.Driver.CmdLine: instance GHC.Base.Monad m => GHC.Base.Monad (GHC.Driver.CmdLine.EwM m)

+ GHC.Driver.CmdLine: instance GHC.Classes.Eq GHC.Driver.CmdLine.WarnReason

+ GHC.Driver.CmdLine: instance GHC.Show.Show GHC.Driver.CmdLine.WarnReason

+ GHC.Driver.CmdLine: instance Json.ToJson GHC.Driver.CmdLine.WarnReason

+ GHC.Driver.CmdLine: instance Outputable.Outputable GHC.Driver.CmdLine.WarnReason

+ GHC.Driver.CmdLine: liftEwM :: Monad m => m a -> EwM m a

+ GHC.Driver.CmdLine: newtype CmdLineP s a

+ GHC.Driver.CmdLine: newtype Err

+ GHC.Driver.CmdLine: processArgs :: Monad m => [Flag m] -> [Located String] -> m ([Located String], [Err], [Warn])

+ GHC.Driver.CmdLine: putCmdLineState :: s -> CmdLineP s ()

+ GHC.Driver.CmdLine: runEwM :: EwM m a -> m (Errs, Warns, a)

+ GHC.Driver.Hooks: cmmToRawCmmHook :: Hooks -> forall a. Maybe (DynFlags -> Maybe Module -> Stream IO CmmGroupSRTs a -> IO (Stream IO RawCmmGroup a))

+ GHC.Driver.Hooks: createIservProcessHook :: Hooks -> Maybe (CreateProcess -> IO ProcessHandle)

+ GHC.Driver.Hooks: data Hooks

+ GHC.Driver.Hooks: dsForeignsHook :: Hooks -> Maybe ([LForeignDecl GhcTc] -> DsM (ForeignStubs, OrdList (Id, CoreExpr)))

+ GHC.Driver.Hooks: emptyHooks :: Hooks

+ GHC.Driver.Hooks: getHooked :: (Functor f, HasDynFlags f) => (Hooks -> Maybe a) -> a -> f a

+ GHC.Driver.Hooks: getValueSafelyHook :: Hooks -> Maybe (HscEnv -> Name -> Type -> IO (Maybe HValue))

+ GHC.Driver.Hooks: ghcPrimIfaceHook :: Hooks -> Maybe ModIface

+ GHC.Driver.Hooks: hscCompileCoreExprHook :: Hooks -> Maybe (HscEnv -> SrcSpan -> CoreExpr -> IO ForeignHValue)

+ GHC.Driver.Hooks: hscFrontendHook :: Hooks -> Maybe (ModSummary -> Hsc FrontendResult)

+ GHC.Driver.Hooks: linkHook :: Hooks -> Maybe (GhcLink -> DynFlags -> Bool -> HomePackageTable -> IO SuccessFlag)

+ GHC.Driver.Hooks: lookupHook :: (Hooks -> Maybe a) -> a -> DynFlags -> a

+ GHC.Driver.Hooks: runMetaHook :: Hooks -> Maybe (MetaHook TcM)

+ GHC.Driver.Hooks: runPhaseHook :: Hooks -> Maybe (PhasePlus -> FilePath -> DynFlags -> CompPipeline (PhasePlus, FilePath))

+ GHC.Driver.Hooks: runRnSpliceHook :: Hooks -> Maybe (HsSplice GhcRn -> RnM (HsSplice GhcRn))

+ GHC.Driver.Hooks: stgToCmmHook :: Hooks -> Maybe (DynFlags -> Module -> [TyCon] -> CollectedCCs -> [CgStgTopBinding] -> HpcInfo -> Stream IO CmmGroup ())

+ GHC.Driver.Hooks: tcForeignExportsHook :: Hooks -> Maybe ([LForeignDecl GhcRn] -> TcM (LHsBinds GhcTcId, [LForeignDecl GhcTcId], Bag GlobalRdrElt))

+ GHC.Driver.Hooks: tcForeignImportsHook :: Hooks -> Maybe ([LForeignDecl GhcRn] -> TcM ([Id], [LForeignDecl GhcTc], Bag GlobalRdrElt))

+ GHC.Driver.Monad: Ghc :: (Session -> IO a) -> Ghc a

+ GHC.Driver.Monad: GhcT :: (Session -> m a) -> GhcT m a

+ GHC.Driver.Monad: Session :: !IORef HscEnv -> Session

+ GHC.Driver.Monad: [unGhcT] :: GhcT m a -> Session -> m a

+ GHC.Driver.Monad: [unGhc] :: Ghc a -> Session -> IO a

+ GHC.Driver.Monad: class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m

+ GHC.Driver.Monad: data Session

+ GHC.Driver.Monad: defaultWarnErrLogger :: WarnErrLogger

+ GHC.Driver.Monad: getSession :: GhcMonad m => m HscEnv

+ GHC.Driver.Monad: getSessionDynFlags :: GhcMonad m => m DynFlags

+ GHC.Driver.Monad: instance Control.Monad.Fix.MonadFix GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance Control.Monad.IO.Class.MonadIO GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance Control.Monad.IO.Class.MonadIO m => GHC.Driver.Session.HasDynFlags (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance Exception.ExceptionMonad GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance Exception.ExceptionMonad m => Exception.ExceptionMonad (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance Exception.ExceptionMonad m => GHC.Driver.Monad.GhcMonad (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance GHC.Base.Applicative GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance GHC.Base.Applicative m => GHC.Base.Applicative (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance GHC.Base.Functor GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance GHC.Base.Functor m => GHC.Base.Functor (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance GHC.Base.Monad GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance GHC.Base.Monad m => GHC.Base.Monad (GHC.Driver.Monad.GhcT m)

+ GHC.Driver.Monad: instance GHC.Driver.Monad.GhcMonad GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: instance GHC.Driver.Session.HasDynFlags GHC.Driver.Monad.Ghc

+ GHC.Driver.Monad: liftGhcT :: m a -> GhcT m a

+ GHC.Driver.Monad: liftIO :: MonadIO m => IO a -> m a

+ GHC.Driver.Monad: logWarnings :: GhcMonad m => WarningMessages -> m ()

+ GHC.Driver.Monad: modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()

+ GHC.Driver.Monad: newtype Ghc a

+ GHC.Driver.Monad: newtype GhcT m a

+ GHC.Driver.Monad: printException :: GhcMonad m => SourceError -> m ()

+ GHC.Driver.Monad: reflectGhc :: Ghc a -> Session -> IO a

+ GHC.Driver.Monad: reifyGhc :: (Session -> IO a) -> Ghc a

+ GHC.Driver.Monad: setSession :: GhcMonad m => HscEnv -> m ()

+ GHC.Driver.Monad: type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()

+ GHC.Driver.Monad: withSession :: GhcMonad m => (HscEnv -> m a) -> m a

+ GHC.Driver.Monad: withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a

+ GHC.Driver.Packages: BrokenDependencies :: [InstalledUnitId] -> UnusablePackageReason

+ GHC.Driver.Packages: CyclicDependencies :: [InstalledUnitId] -> UnusablePackageReason

+ GHC.Driver.Packages: IgnoredDependencies :: [InstalledUnitId] -> UnusablePackageReason

+ GHC.Driver.Packages: IgnoredWithFlag :: UnusablePackageReason

+ GHC.Driver.Packages: LookupFound :: Module -> UnitInfo -> LookupResult

+ GHC.Driver.Packages: LookupHidden :: [(Module, ModuleOrigin)] -> [(Module, ModuleOrigin)] -> LookupResult

+ GHC.Driver.Packages: LookupMultiple :: [(Module, ModuleOrigin)] -> LookupResult

+ GHC.Driver.Packages: LookupNotFound :: [ModuleSuggestion] -> LookupResult

+ GHC.Driver.Packages: LookupUnusable :: [(Module, ModuleOrigin)] -> LookupResult

+ GHC.Driver.Packages: ModHidden :: ModuleOrigin

+ GHC.Driver.Packages: ModOrigin :: Maybe Bool -> [UnitInfo] -> [UnitInfo] -> Bool -> ModuleOrigin

+ GHC.Driver.Packages: ModUnusable :: UnusablePackageReason -> ModuleOrigin

+ GHC.Driver.Packages: PackageDatabase :: FilePath -> [UnitInfo] -> PackageDatabase

+ GHC.Driver.Packages: ShadowedDependencies :: [InstalledUnitId] -> UnusablePackageReason

+ GHC.Driver.Packages: SuggestHidden :: ModuleName -> Module -> ModuleOrigin -> ModuleSuggestion

+ GHC.Driver.Packages: SuggestVisible :: ModuleName -> Module -> ModuleOrigin -> ModuleSuggestion

+ GHC.Driver.Packages: [fromExposedReexport] :: ModuleOrigin -> [UnitInfo]

+ GHC.Driver.Packages: [fromHiddenReexport] :: ModuleOrigin -> [UnitInfo]

+ GHC.Driver.Packages: [fromOrigPackage] :: ModuleOrigin -> Maybe Bool

+ GHC.Driver.Packages: [fromPackageFlag] :: ModuleOrigin -> Bool

+ GHC.Driver.Packages: [packageDatabasePath] :: PackageDatabase -> FilePath

+ GHC.Driver.Packages: [packageDatabaseUnits] :: PackageDatabase -> [UnitInfo]

+ GHC.Driver.Packages: collectArchives :: DynFlags -> UnitInfo -> IO [FilePath]

+ GHC.Driver.Packages: collectIncludeDirs :: [UnitInfo] -> [FilePath]

+ GHC.Driver.Packages: collectLibraryPaths :: DynFlags -> [UnitInfo] -> [FilePath]

+ GHC.Driver.Packages: collectLinkOpts :: DynFlags -> [UnitInfo] -> ([String], [String], [String])

+ GHC.Driver.Packages: componentIdString :: DynFlags -> ComponentId -> Maybe String

+ GHC.Driver.Packages: data LookupResult

+ GHC.Driver.Packages: data ModuleOrigin

+ GHC.Driver.Packages: data ModuleSuggestion

+ GHC.Driver.Packages: data PackageDatabase

+ GHC.Driver.Packages: data PackageState

+ GHC.Driver.Packages: data UnitInfoMap

+ GHC.Driver.Packages: data UnusablePackageReason

+ GHC.Driver.Packages: displayInstalledUnitId :: DynFlags -> InstalledUnitId -> Maybe String

+ GHC.Driver.Packages: emptyPackageState :: PackageState

+ GHC.Driver.Packages: getInstalledPackageDetails :: HasDebugCallStack => DynFlags -> InstalledUnitId -> UnitInfo

+ GHC.Driver.Packages: getLibs :: DynFlags -> [PreloadUnitId] -> IO [(String, String)]

+ GHC.Driver.Packages: getPackageConfRefs :: DynFlags -> IO [PkgDbRef]

+ GHC.Driver.Packages: getPackageDetails :: HasDebugCallStack => DynFlags -> UnitId -> UnitInfo

+ GHC.Driver.Packages: getPackageExtraCcOpts :: DynFlags -> [PreloadUnitId] -> IO [String]

+ GHC.Driver.Packages: getPackageFrameworkPath :: DynFlags -> [PreloadUnitId] -> IO [String]

+ GHC.Driver.Packages: getPackageFrameworks :: DynFlags -> [PreloadUnitId] -> IO [String]

+ GHC.Driver.Packages: getPackageIncludePath :: DynFlags -> [PreloadUnitId] -> IO [String]

+ GHC.Driver.Packages: getPackageLibraryPath :: DynFlags -> [PreloadUnitId] -> IO [String]

+ GHC.Driver.Packages: getPackageLinkOpts :: DynFlags -> [PreloadUnitId] -> IO ([String], [String], [String])

+ GHC.Driver.Packages: getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [UnitInfo]

+ GHC.Driver.Packages: getUnitInfoMap :: DynFlags -> UnitInfoMap

+ GHC.Driver.Packages: improveUnitId :: UnitInfoMap -> UnitId -> UnitId

+ GHC.Driver.Packages: initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId])

+ GHC.Driver.Packages: instance GHC.Base.Monoid GHC.Driver.Packages.ModuleOrigin

+ GHC.Driver.Packages: instance GHC.Base.Monoid GHC.Driver.Packages.UnitVisibility

+ GHC.Driver.Packages: instance GHC.Base.Semigroup GHC.Driver.Packages.ModuleOrigin

+ GHC.Driver.Packages: instance GHC.Base.Semigroup GHC.Driver.Packages.UnitVisibility

+ GHC.Driver.Packages: instance Outputable.Outputable GHC.Driver.Packages.ModuleOrigin

+ GHC.Driver.Packages: instance Outputable.Outputable GHC.Driver.Packages.UnitVisibility

+ GHC.Driver.Packages: instance Outputable.Outputable GHC.Driver.Packages.UnusablePackageReason

+ GHC.Driver.Packages: isDllName :: DynFlags -> Module -> Name -> Bool

+ GHC.Driver.Packages: isIndefinite :: DynFlags -> Bool

+ GHC.Driver.Packages: listUnitInfoMap :: DynFlags -> [UnitInfo]

+ GHC.Driver.Packages: listVisibleModuleNames :: DynFlags -> [ModuleName]

+ GHC.Driver.Packages: lookupInstalledPackage :: DynFlags -> InstalledUnitId -> Maybe UnitInfo

+ GHC.Driver.Packages: lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, UnitInfo)]

+ GHC.Driver.Packages: lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult

+ GHC.Driver.Packages: lookupPackageName :: DynFlags -> PackageName -> Maybe ComponentId

+ GHC.Driver.Packages: lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult

+ GHC.Driver.Packages: lookupUnit :: DynFlags -> UnitId -> Maybe UnitInfo

+ GHC.Driver.Packages: lookupUnit' :: Bool -> UnitInfoMap -> UnitId -> Maybe UnitInfo

+ GHC.Driver.Packages: packageHsLibs :: DynFlags -> UnitInfo -> [String]

+ GHC.Driver.Packages: pprFlag :: PackageFlag -> SDoc

+ GHC.Driver.Packages: pprModuleMap :: ModuleNameProvidersMap -> SDoc

+ GHC.Driver.Packages: pprPackages :: DynFlags -> SDoc

+ GHC.Driver.Packages: pprPackagesSimple :: DynFlags -> SDoc

+ GHC.Driver.Packages: pprReason :: SDoc -> UnusablePackageReason -> SDoc

+ GHC.Driver.Packages: readPackageDatabase :: DynFlags -> FilePath -> IO PackageDatabase

+ GHC.Driver.Packages: readPackageDatabases :: DynFlags -> IO [PackageDatabase]

+ GHC.Driver.Packages: resolvePackageDatabase :: DynFlags -> PkgDbRef -> IO (Maybe FilePath)

+ GHC.Driver.Packages: searchPackageId :: DynFlags -> SourcePackageId -> [UnitInfo]

+ GHC.Driver.Packages: unwireUnitId :: DynFlags -> UnitId -> UnitId

+ GHC.Driver.Phases: As :: Bool -> Phase

+ GHC.Driver.Phases: Cc :: Phase

+ GHC.Driver.Phases: Ccxx :: Phase

+ GHC.Driver.Phases: Cmm :: Phase

+ GHC.Driver.Phases: CmmCpp :: Phase

+ GHC.Driver.Phases: Cobjc :: Phase

+ GHC.Driver.Phases: Cobjcxx :: Phase

+ GHC.Driver.Phases: Cpp :: HscSource -> Phase

+ GHC.Driver.Phases: HCc :: Phase

+ GHC.Driver.Phases: HsBootFile :: HscSource

+ GHC.Driver.Phases: HsPp :: HscSource -> Phase

+ GHC.Driver.Phases: HsSrcFile :: HscSource

+ GHC.Driver.Phases: Hsc :: HscSource -> Phase

+ GHC.Driver.Phases: HsigFile :: HscSource

+ GHC.Driver.Phases: LlvmLlc :: Phase

+ GHC.Driver.Phases: LlvmMangle :: Phase

+ GHC.Driver.Phases: LlvmOpt :: Phase

+ GHC.Driver.Phases: MergeForeign :: Phase

+ GHC.Driver.Phases: StopLn :: Phase

+ GHC.Driver.Phases: Unlit :: HscSource -> Phase

+ GHC.Driver.Phases: anyHsc :: Phase

+ GHC.Driver.Phases: data HscSource

+ GHC.Driver.Phases: data Phase

+ GHC.Driver.Phases: eqPhase :: Phase -> Phase -> Bool

+ GHC.Driver.Phases: happensBefore :: DynFlags -> Phase -> Phase -> Bool

+ GHC.Driver.Phases: hscSourceString :: HscSource -> String

+ GHC.Driver.Phases: instance Binary.Binary GHC.Driver.Phases.HscSource

+ GHC.Driver.Phases: instance GHC.Classes.Eq GHC.Driver.Phases.HscSource

+ GHC.Driver.Phases: instance GHC.Classes.Eq GHC.Driver.Phases.Phase

+ GHC.Driver.Phases: instance GHC.Classes.Ord GHC.Driver.Phases.HscSource

+ GHC.Driver.Phases: instance GHC.Show.Show GHC.Driver.Phases.HscSource

+ GHC.Driver.Phases: instance GHC.Show.Show GHC.Driver.Phases.Phase

+ GHC.Driver.Phases: instance Outputable.Outputable GHC.Driver.Phases.Phase

+ GHC.Driver.Phases: isBackpackishSuffix :: String -> Bool

+ GHC.Driver.Phases: isCishFilename :: FilePath -> Bool

+ GHC.Driver.Phases: isCishSuffix :: String -> Bool

+ GHC.Driver.Phases: isDynLibFilename :: Platform -> FilePath -> Bool

+ GHC.Driver.Phases: isDynLibSuffix :: Platform -> String -> Bool

+ GHC.Driver.Phases: isHaskellSigFilename :: FilePath -> Bool

+ GHC.Driver.Phases: isHaskellSigSuffix :: String -> Bool

+ GHC.Driver.Phases: isHaskellSrcFilename :: FilePath -> Bool

+ GHC.Driver.Phases: isHaskellSrcSuffix :: String -> Bool

+ GHC.Driver.Phases: isHaskellUserSrcFilename :: FilePath -> Bool

+ GHC.Driver.Phases: isHaskellUserSrcSuffix :: String -> Bool

+ GHC.Driver.Phases: isHaskellishFilename :: FilePath -> Bool

+ GHC.Driver.Phases: isHaskellishSuffix :: String -> Bool

+ GHC.Driver.Phases: isHaskellishTarget :: (String, Maybe Phase) -> Bool

+ GHC.Driver.Phases: isHsBootOrSig :: HscSource -> Bool

+ GHC.Driver.Phases: isHsigFile :: HscSource -> Bool

+ GHC.Driver.Phases: isObjectFilename :: Platform -> FilePath -> Bool

+ GHC.Driver.Phases: isObjectSuffix :: Platform -> String -> Bool

+ GHC.Driver.Phases: isSourceFilename :: FilePath -> Bool

+ GHC.Driver.Phases: isSourceSuffix :: String -> Bool

+ GHC.Driver.Phases: isStopLn :: Phase -> Bool

+ GHC.Driver.Phases: phaseInputExt :: Phase -> String

+ GHC.Driver.Phases: startPhase :: String -> Phase

+ GHC.Driver.Pipeline.Monad: HscOut :: HscSource -> ModuleName -> HscStatus -> PhasePlus

+ GHC.Driver.Pipeline.Monad: P :: (PipeEnv -> PipeState -> IO (PipeState, a)) -> CompPipeline a

+ GHC.Driver.Pipeline.Monad: Persistent :: PipelineOutput

+ GHC.Driver.Pipeline.Monad: PipeEnv :: Phase -> String -> String -> String -> PipelineOutput -> PipeEnv

+ GHC.Driver.Pipeline.Monad: PipeState :: HscEnv -> Maybe ModLocation -> [FilePath] -> Maybe (ModIface, ModDetails) -> PipeState

+ GHC.Driver.Pipeline.Monad: RealPhase :: Phase -> PhasePlus

+ GHC.Driver.Pipeline.Monad: SpecificFile :: PipelineOutput

+ GHC.Driver.Pipeline.Monad: Temporary :: TempFileLifetime -> PipelineOutput

+ GHC.Driver.Pipeline.Monad: [foreign_os] :: PipeState -> [FilePath]

+ GHC.Driver.Pipeline.Monad: [hsc_env] :: PipeState -> HscEnv

+ GHC.Driver.Pipeline.Monad: [iface] :: PipeState -> Maybe (ModIface, ModDetails)

+ GHC.Driver.Pipeline.Monad: [maybe_loc] :: PipeState -> Maybe ModLocation

+ GHC.Driver.Pipeline.Monad: [output_spec] :: PipeEnv -> PipelineOutput

+ GHC.Driver.Pipeline.Monad: [src_basename] :: PipeEnv -> String

+ GHC.Driver.Pipeline.Monad: [src_filename] :: PipeEnv -> String

+ GHC.Driver.Pipeline.Monad: [src_suffix] :: PipeEnv -> String

+ GHC.Driver.Pipeline.Monad: [stop_phase] :: PipeEnv -> Phase

+ GHC.Driver.Pipeline.Monad: [unP] :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)

+ GHC.Driver.Pipeline.Monad: data PhasePlus

+ GHC.Driver.Pipeline.Monad: data PipeEnv

+ GHC.Driver.Pipeline.Monad: data PipeState

+ GHC.Driver.Pipeline.Monad: data PipelineOutput

+ GHC.Driver.Pipeline.Monad: evalP :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)

+ GHC.Driver.Pipeline.Monad: getPipeEnv :: CompPipeline PipeEnv

+ GHC.Driver.Pipeline.Monad: getPipeState :: CompPipeline PipeState

+ GHC.Driver.Pipeline.Monad: instance Control.Monad.IO.Class.MonadIO GHC.Driver.Pipeline.Monad.CompPipeline

+ GHC.Driver.Pipeline.Monad: instance GHC.Base.Applicative GHC.Driver.Pipeline.Monad.CompPipeline

+ GHC.Driver.Pipeline.Monad: instance GHC.Base.Functor GHC.Driver.Pipeline.Monad.CompPipeline

+ GHC.Driver.Pipeline.Monad: instance GHC.Base.Monad GHC.Driver.Pipeline.Monad.CompPipeline

+ GHC.Driver.Pipeline.Monad: instance GHC.Driver.Session.HasDynFlags GHC.Driver.Pipeline.Monad.CompPipeline

+ GHC.Driver.Pipeline.Monad: instance GHC.Show.Show GHC.Driver.Pipeline.Monad.PipelineOutput

+ GHC.Driver.Pipeline.Monad: instance Outputable.Outputable GHC.Driver.Pipeline.Monad.PhasePlus

+ GHC.Driver.Pipeline.Monad: newtype CompPipeline a

+ GHC.Driver.Pipeline.Monad: pipeStateDynFlags :: PipeState -> DynFlags

+ GHC.Driver.Pipeline.Monad: pipeStateModIface :: PipeState -> Maybe (ModIface, ModDetails)

+ GHC.Driver.Pipeline.Monad: setDynFlags :: DynFlags -> CompPipeline ()

+ GHC.Driver.Pipeline.Monad: setForeignOs :: [FilePath] -> CompPipeline ()

+ GHC.Driver.Pipeline.Monad: setIface :: ModIface -> ModDetails -> CompPipeline ()

+ GHC.Driver.Pipeline.Monad: setModLocation :: ModLocation -> CompPipeline ()

+ GHC.Driver.Plugins: ForceRecompile :: PluginRecompile

+ GHC.Driver.Plugins: FrontendPlugin :: FrontendPluginAction -> FrontendPlugin

+ GHC.Driver.Plugins: LoadedPlugin :: PluginWithArgs -> ModIface -> LoadedPlugin

+ GHC.Driver.Plugins: MaybeRecompile :: Fingerprint -> PluginRecompile

+ GHC.Driver.Plugins: NoForceRecompile :: PluginRecompile

+ GHC.Driver.Plugins: Plugin :: CorePlugin -> TcPlugin -> HoleFitPlugin -> ([CommandLineOption] -> DynFlags -> IO DynFlags) -> ([CommandLineOption] -> IO PluginRecompile) -> ([CommandLineOption] -> ModSummary -> HsParsedModule -> Hsc HsParsedModule) -> ([CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)) -> ([CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv) -> ([CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)) -> (forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface) -> Plugin

+ GHC.Driver.Plugins: PluginWithArgs :: Plugin -> [CommandLineOption] -> PluginWithArgs

+ GHC.Driver.Plugins: StaticPlugin :: PluginWithArgs -> StaticPlugin

+ GHC.Driver.Plugins: [dynflagsPlugin] :: Plugin -> [CommandLineOption] -> DynFlags -> IO DynFlags

+ GHC.Driver.Plugins: [frontend] :: FrontendPlugin -> FrontendPluginAction

+ GHC.Driver.Plugins: [holeFitPlugin] :: Plugin -> HoleFitPlugin

+ GHC.Driver.Plugins: [installCoreToDos] :: Plugin -> CorePlugin

+ GHC.Driver.Plugins: [interfaceLoadAction] :: Plugin -> forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface

+ GHC.Driver.Plugins: [lpModule] :: LoadedPlugin -> ModIface

+ GHC.Driver.Plugins: [lpPlugin] :: LoadedPlugin -> PluginWithArgs

+ GHC.Driver.Plugins: [paArguments] :: PluginWithArgs -> [CommandLineOption]

+ GHC.Driver.Plugins: [paPlugin] :: PluginWithArgs -> Plugin

+ GHC.Driver.Plugins: [parsedResultAction] :: Plugin -> [CommandLineOption] -> ModSummary -> HsParsedModule -> Hsc HsParsedModule

+ GHC.Driver.Plugins: [pluginRecompile] :: Plugin -> [CommandLineOption] -> IO PluginRecompile

+ GHC.Driver.Plugins: [renamedResultAction] :: Plugin -> [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

+ GHC.Driver.Plugins: [spPlugin] :: StaticPlugin -> PluginWithArgs

+ GHC.Driver.Plugins: [spliceRunAction] :: Plugin -> [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)

+ GHC.Driver.Plugins: [tcPlugin] :: Plugin -> TcPlugin

+ GHC.Driver.Plugins: [typeCheckResultAction] :: Plugin -> [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv

+ GHC.Driver.Plugins: data FrontendPlugin

+ GHC.Driver.Plugins: data HoleFitPluginR

+ GHC.Driver.Plugins: data LoadedPlugin

+ GHC.Driver.Plugins: data Plugin

+ GHC.Driver.Plugins: data PluginRecompile

+ GHC.Driver.Plugins: data PluginWithArgs

+ GHC.Driver.Plugins: data StaticPlugin

+ GHC.Driver.Plugins: defaultFrontendPlugin :: FrontendPlugin

+ GHC.Driver.Plugins: defaultPlugin :: Plugin

+ GHC.Driver.Plugins: flagRecompile :: [CommandLineOption] -> IO PluginRecompile

+ GHC.Driver.Plugins: impurePlugin :: [CommandLineOption] -> IO PluginRecompile

+ GHC.Driver.Plugins: instance GHC.Base.Monoid GHC.Driver.Plugins.PluginRecompile

+ GHC.Driver.Plugins: instance GHC.Base.Semigroup GHC.Driver.Plugins.PluginRecompile

+ GHC.Driver.Plugins: instance Outputable.Outputable GHC.Driver.Plugins.PluginRecompile

+ GHC.Driver.Plugins: keepRenamedSource :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

+ GHC.Driver.Plugins: lpModuleName :: LoadedPlugin -> ModuleName

+ GHC.Driver.Plugins: mapPlugins :: DynFlags -> (Plugin -> [CommandLineOption] -> a) -> [a]

+ GHC.Driver.Plugins: pluginRecompile' :: PluginWithArgs -> IO PluginRecompile

+ GHC.Driver.Plugins: plugins :: DynFlags -> [PluginWithArgs]

+ GHC.Driver.Plugins: purePlugin :: [CommandLineOption] -> IO PluginRecompile

+ GHC.Driver.Plugins: type CommandLineOption = String

+ GHC.Driver.Plugins: type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]

+ GHC.Driver.Plugins: type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()

+ GHC.Driver.Plugins: type TcPlugin = [CommandLineOption] -> Maybe TcPlugin

+ GHC.Driver.Plugins: withPlugins :: Monad m => DynFlags -> PluginOperation m a -> a -> m a

+ GHC.Driver.Plugins: withPlugins_ :: Monad m => DynFlags -> ConstPluginOperation m a -> a -> m ()

+ GHC.Driver.Session: AixLD :: [Option] -> LinkerInfo

+ GHC.Driver.Session: AppleClang :: CompilerInfo

+ GHC.Driver.Session: AppleClang51 :: CompilerInfo

+ GHC.Driver.Session: CFGWeights :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> CfgWeights

+ GHC.Driver.Session: Clang :: CompilerInfo

+ GHC.Driver.Session: ClearPackageDBs :: PackageDBFlag

+ GHC.Driver.Session: CompManager :: GhcMode

+ GHC.Driver.Session: DarwinLD :: [Option] -> LinkerInfo

+ GHC.Driver.Session: Deployable :: DynLibLoader

+ GHC.Driver.Session: DistrustPackage :: String -> TrustFlag

+ GHC.Driver.Session: DynFlags :: GhcMode -> GhcLink -> HscTarget -> {-# UNPACK #-} !GhcNameVersion -> {-# UNPACK #-} !FileSettings -> Platform -> {-# UNPACK #-} !ToolSettings -> {-# UNPACK #-} !PlatformMisc -> PlatformConstants -> [(String, String)] -> IntegerLibrary -> LlvmConfig -> Int -> Int -> Int -> Int -> Int -> Maybe String -> Maybe String -> [Int] -> Maybe Int -> Bool -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Int -> Int -> Int -> Maybe Int -> Maybe Int -> Int -> Word -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Bool -> 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 -> Maybe String -> String -> String -> String -> String -> IORef Bool -> String -> String -> Maybe String -> Maybe String -> Maybe String -> DynLibLoader -> Maybe FilePath -> Maybe FilePath -> [Option] -> IncludeSpecs -> [String] -> [String] -> [String] -> Maybe String -> RtsOptsEnabled -> Bool -> String -> [ModuleName] -> [(ModuleName, String)] -> [String] -> [LoadedPlugin] -> [StaticPlugin] -> Hooks -> FilePath -> Bool -> Bool -> [ModuleName] -> [String] -> [PackageDBFlag] -> [IgnorePackageFlag] -> [PackageFlag] -> [PackageFlag] -> [TrustFlag] -> Maybe FilePath -> Maybe [PackageDatabase] -> 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 -> LogAction -> DumpAction -> TraceAction -> 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 -> CfgWeights -> DynFlags

+ GHC.Driver.Session: ErrReason :: !Maybe WarningFlag -> WarnReason

+ GHC.Driver.Session: ExposePackage :: String -> PackageArg -> ModRenaming -> PackageFlag

+ GHC.Driver.Session: FileOption :: String -> String -> Option

+ GHC.Driver.Session: FileSettings :: FilePath -> FilePath -> Maybe FilePath -> FilePath -> String -> FilePath -> FileSettings

+ GHC.Driver.Session: FilesToClean :: !Set FilePath -> !Set FilePath -> FilesToClean

+ GHC.Driver.Session: FlagSpec :: String -> flag -> (TurnOnFlag -> DynP ()) -> GhcFlagMode -> FlagSpec flag

+ GHC.Driver.Session: FlushErr :: IO () -> FlushErr

+ GHC.Driver.Session: FlushOut :: IO () -> FlushOut

+ GHC.Driver.Session: GCC :: CompilerInfo

+ GHC.Driver.Session: GhcNameVersion :: String -> String -> GhcNameVersion

+ GHC.Driver.Session: GlobalPkgDb :: PkgDbRef

+ GHC.Driver.Session: GnuGold :: [Option] -> LinkerInfo

+ GHC.Driver.Session: GnuLD :: [Option] -> LinkerInfo

+ GHC.Driver.Session: Haskell2010 :: Language

+ GHC.Driver.Session: Haskell98 :: Language

+ GHC.Driver.Session: HidePackage :: String -> PackageFlag

+ GHC.Driver.Session: HscAsm :: HscTarget

+ GHC.Driver.Session: HscC :: HscTarget

+ GHC.Driver.Session: HscInterpreted :: HscTarget

+ GHC.Driver.Session: HscLlvm :: HscTarget

+ GHC.Driver.Session: HscNothing :: HscTarget

+ GHC.Driver.Session: IgnorePackage :: String -> IgnorePackageFlag

+ GHC.Driver.Session: IncludeSpecs :: [String] -> [String] -> IncludeSpecs

+ GHC.Driver.Session: IntegerGMP :: IntegerLibrary

+ GHC.Driver.Session: IntegerSimple :: IntegerLibrary

+ GHC.Driver.Session: LinkBinary :: GhcLink

+ GHC.Driver.Session: LinkDynLib :: GhcLink

+ GHC.Driver.Session: LinkInMemory :: GhcLink

+ GHC.Driver.Session: LinkStaticLib :: GhcLink

+ GHC.Driver.Session: LlvmConfig :: [(String, LlvmTarget)] -> [(Int, String)] -> LlvmConfig

+ GHC.Driver.Session: LlvmLLD :: [Option] -> LinkerInfo

+ GHC.Driver.Session: LlvmTarget :: String -> String -> [String] -> LlvmTarget

+ GHC.Driver.Session: MkDepend :: GhcMode

+ GHC.Driver.Session: ModRenaming :: Bool -> [(ModuleName, ModuleName)] -> ModRenaming

+ GHC.Driver.Session: NoGlobalPackageDB :: PackageDBFlag

+ GHC.Driver.Session: NoLink :: GhcLink

+ GHC.Driver.Session: NoProfAuto :: ProfAuto

+ GHC.Driver.Session: NoReason :: WarnReason

+ GHC.Driver.Session: NoUserPackageDB :: PackageDBFlag

+ GHC.Driver.Session: OneShot :: GhcMode

+ GHC.Driver.Session: Opt_AbstractRefHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_AlignmentSanitisation :: GeneralFlag

+ GHC.Driver.Session: Opt_AsmShortcutting :: GeneralFlag

+ GHC.Driver.Session: Opt_AutoLinkPackages :: GeneralFlag

+ GHC.Driver.Session: Opt_AutoSccsOnIndividualCafs :: GeneralFlag

+ GHC.Driver.Session: Opt_BreakOnError :: GeneralFlag

+ GHC.Driver.Session: Opt_BreakOnException :: GeneralFlag

+ GHC.Driver.Session: Opt_BuildDynamicToo :: GeneralFlag

+ GHC.Driver.Session: Opt_BuildingCabalPackage :: GeneralFlag

+ GHC.Driver.Session: Opt_ByteCode :: GeneralFlag

+ GHC.Driver.Session: Opt_CSE :: GeneralFlag

+ GHC.Driver.Session: Opt_CallArity :: GeneralFlag

+ GHC.Driver.Session: Opt_CaseFolding :: GeneralFlag

+ GHC.Driver.Session: Opt_CaseMerge :: GeneralFlag

+ GHC.Driver.Session: Opt_CatchBottoms :: GeneralFlag

+ GHC.Driver.Session: Opt_CfgBlocklayout :: GeneralFlag

+ GHC.Driver.Session: Opt_CmmElimCommonBlocks :: GeneralFlag

+ GHC.Driver.Session: Opt_CmmSink :: GeneralFlag

+ GHC.Driver.Session: Opt_CprAnal :: GeneralFlag

+ GHC.Driver.Session: Opt_CrossModuleSpecialise :: GeneralFlag

+ GHC.Driver.Session: Opt_D_dump_BCOs :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_conflicts :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_expanded :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_liveness :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_native :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_regalloc :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_regalloc_stages :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_asm_stats :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_call_arity :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cfg_weights :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_caf :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_cbe :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_cfg :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_cps :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_from_stg :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_info :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_proc :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_procmap :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_raw :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_sink :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_sp :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_split :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_switch :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_verbose :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cmm_verbose_by_proc :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_core_stats :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cpr_signatures :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cpranal :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cs_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_cse :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_debug :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_deriv :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_ds :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_ds_preopt :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_ec_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_exitify :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_foreign :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_hi :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_hi_diffs :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_if_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_inlinings :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_json :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_llvm :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_minimal_imports :: GeneralFlag

+ GHC.Driver.Session: Opt_D_dump_mod_cycles :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_mod_map :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_occur_anal :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_opt_cmm :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_parsed :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_parsed_ast :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_prep :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rn :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rn_ast :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rn_stats :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rn_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rtti :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rule_firings :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rule_rewrites :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_rules :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_simpl :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_simpl_iterations :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_simpl_stats :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_simpl_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_spec :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_splices :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_stg :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_stg_final :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_stg_unarised :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_str_signatures :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_stranal :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_tc :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_tc_ast :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_tc_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_ticked :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_timings :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_types :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_view_pattern_commoning :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_vt_trace :: DumpFlag

+ GHC.Driver.Session: Opt_D_dump_worker_wrapper :: DumpFlag

+ GHC.Driver.Session: Opt_D_faststring_stats :: GeneralFlag

+ GHC.Driver.Session: Opt_D_no_debug_output :: DumpFlag

+ GHC.Driver.Session: Opt_D_ppr_debug :: DumpFlag

+ GHC.Driver.Session: Opt_D_source_stats :: DumpFlag

+ GHC.Driver.Session: Opt_D_th_dec_file :: DumpFlag

+ GHC.Driver.Session: Opt_D_verbose_core2core :: DumpFlag

+ GHC.Driver.Session: Opt_D_verbose_stg2stg :: DumpFlag

+ GHC.Driver.Session: Opt_DeferDiagnostics :: GeneralFlag

+ GHC.Driver.Session: Opt_DeferOutOfScopeVariables :: GeneralFlag

+ GHC.Driver.Session: Opt_DeferTypeErrors :: GeneralFlag

+ GHC.Driver.Session: Opt_DeferTypedHoles :: GeneralFlag

+ GHC.Driver.Session: Opt_DiagnosticsShowCaret :: GeneralFlag

+ GHC.Driver.Session: Opt_DictsCheap :: GeneralFlag

+ GHC.Driver.Session: Opt_DictsStrict :: GeneralFlag

+ GHC.Driver.Session: Opt_DistrustAllPackages :: GeneralFlag

+ GHC.Driver.Session: Opt_DmdTxDictSel :: GeneralFlag

+ GHC.Driver.Session: Opt_DoAnnotationLinting :: GeneralFlag

+ GHC.Driver.Session: Opt_DoAsmLinting :: GeneralFlag

+ GHC.Driver.Session: Opt_DoCmmLinting :: GeneralFlag

+ GHC.Driver.Session: Opt_DoCoreLinting :: GeneralFlag

+ GHC.Driver.Session: Opt_DoEtaReduction :: GeneralFlag

+ GHC.Driver.Session: Opt_DoLambdaEtaExpansion :: GeneralFlag

+ GHC.Driver.Session: Opt_DoStgLinting :: GeneralFlag

+ GHC.Driver.Session: Opt_DumpToFile :: GeneralFlag

+ GHC.Driver.Session: Opt_EagerBlackHoling :: GeneralFlag

+ GHC.Driver.Session: Opt_EmbedManifest :: GeneralFlag

+ GHC.Driver.Session: Opt_EnableRewriteRules :: GeneralFlag

+ GHC.Driver.Session: Opt_EnableThSpliceWarnings :: GeneralFlag

+ GHC.Driver.Session: Opt_ErrorSpans :: GeneralFlag

+ GHC.Driver.Session: Opt_ExcessPrecision :: GeneralFlag

+ GHC.Driver.Session: Opt_Exitification :: GeneralFlag

+ GHC.Driver.Session: Opt_ExposeAllUnfoldings :: GeneralFlag

+ GHC.Driver.Session: Opt_ExternalDynamicRefs :: GeneralFlag

+ GHC.Driver.Session: Opt_ExternalInterpreter :: GeneralFlag

+ GHC.Driver.Session: Opt_FastLlvm :: GeneralFlag

+ GHC.Driver.Session: Opt_FlatCache :: GeneralFlag

+ GHC.Driver.Session: Opt_FloatIn :: GeneralFlag

+ GHC.Driver.Session: Opt_ForceRecomp :: GeneralFlag

+ GHC.Driver.Session: Opt_FullLaziness :: GeneralFlag

+ GHC.Driver.Session: Opt_FunToThunk :: GeneralFlag

+ GHC.Driver.Session: Opt_G_NoOptCoercion :: GeneralFlag

+ GHC.Driver.Session: Opt_G_NoStateHack :: GeneralFlag

+ GHC.Driver.Session: Opt_GenManifest :: GeneralFlag

+ GHC.Driver.Session: Opt_GhciHistory :: GeneralFlag

+ GHC.Driver.Session: Opt_GhciLeakCheck :: GeneralFlag

+ GHC.Driver.Session: Opt_GhciSandbox :: GeneralFlag

+ GHC.Driver.Session: Opt_Haddock :: GeneralFlag

+ GHC.Driver.Session: Opt_HaddockOptions :: GeneralFlag

+ GHC.Driver.Session: Opt_HelpfulErrors :: GeneralFlag

+ GHC.Driver.Session: Opt_HexWordLiterals :: GeneralFlag

+ GHC.Driver.Session: Opt_HideAllPackages :: GeneralFlag

+ GHC.Driver.Session: Opt_HideAllPluginPackages :: GeneralFlag

+ GHC.Driver.Session: Opt_HideSourcePaths :: GeneralFlag

+ GHC.Driver.Session: Opt_Hpc :: GeneralFlag

+ GHC.Driver.Session: Opt_IgnoreAsserts :: GeneralFlag

+ GHC.Driver.Session: Opt_IgnoreDotGhci :: GeneralFlag

+ GHC.Driver.Session: Opt_IgnoreHpcChanges :: GeneralFlag

+ GHC.Driver.Session: Opt_IgnoreInterfacePragmas :: GeneralFlag

+ GHC.Driver.Session: Opt_IgnoreOptimChanges :: GeneralFlag

+ GHC.Driver.Session: Opt_ImplicitImportQualified :: GeneralFlag

+ GHC.Driver.Session: Opt_IrrefutableTuples :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepCAFs :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepGoing :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepHcFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepHiDiffs :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepHiFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepHscppFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepLlvmFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepOFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepRawTokenStream :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepSFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KeepTmpFiles :: GeneralFlag

+ GHC.Driver.Session: Opt_KillAbsence :: GeneralFlag

+ GHC.Driver.Session: Opt_KillOneShot :: GeneralFlag

+ GHC.Driver.Session: Opt_LateDmdAnal :: GeneralFlag

+ GHC.Driver.Session: Opt_LateSpecialise :: GeneralFlag

+ GHC.Driver.Session: Opt_LiberateCase :: GeneralFlag

+ GHC.Driver.Session: Opt_LlvmFillUndefWithGarbage :: GeneralFlag

+ GHC.Driver.Session: Opt_LlvmTBAA :: GeneralFlag

+ GHC.Driver.Session: Opt_LocalGhciHistory :: GeneralFlag

+ GHC.Driver.Session: Opt_Loopification :: GeneralFlag

+ GHC.Driver.Session: Opt_NoHsMain :: GeneralFlag

+ GHC.Driver.Session: Opt_NoIt :: GeneralFlag

+ GHC.Driver.Session: Opt_NoLlvmMangler :: GeneralFlag

+ GHC.Driver.Session: Opt_NoTypeableBinds :: GeneralFlag

+ GHC.Driver.Session: Opt_NumConstantFolding :: GeneralFlag

+ GHC.Driver.Session: Opt_OmitInterfacePragmas :: GeneralFlag

+ GHC.Driver.Session: Opt_OmitYields :: GeneralFlag

+ GHC.Driver.Session: Opt_OptimalApplicativeDo :: GeneralFlag

+ GHC.Driver.Session: Opt_PIC :: GeneralFlag

+ GHC.Driver.Session: Opt_PICExecutable :: GeneralFlag

+ GHC.Driver.Session: Opt_PIE :: GeneralFlag

+ GHC.Driver.Session: Opt_PackageTrust :: GeneralFlag

+ GHC.Driver.Session: Opt_PedanticBottoms :: GeneralFlag

+ GHC.Driver.Session: Opt_PluginTrustworthy :: GeneralFlag

+ GHC.Driver.Session: Opt_Pp :: GeneralFlag

+ GHC.Driver.Session: Opt_PprCaseAsLet :: GeneralFlag

+ GHC.Driver.Session: Opt_PprShowTicks :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintAxiomIncomps :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintBindContents :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintBindResult :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintEqualityRelations :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintEvldWithShow :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintExpandedSynonyms :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintExplicitCoercions :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintExplicitForalls :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintExplicitKinds :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintExplicitRuntimeReps :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintPotentialInstances :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintTypecheckerElaboration :: GeneralFlag

+ GHC.Driver.Session: Opt_PrintUnicodeSyntax :: GeneralFlag

+ GHC.Driver.Session: Opt_ProfCountEntries :: GeneralFlag

+ GHC.Driver.Session: Opt_RPath :: GeneralFlag

+ GHC.Driver.Session: Opt_RegsGraph :: GeneralFlag

+ GHC.Driver.Session: Opt_RegsIterative :: GeneralFlag

+ GHC.Driver.Session: Opt_RelativeDynlibPaths :: GeneralFlag

+ GHC.Driver.Session: Opt_SccProfilingOn :: GeneralFlag

+ GHC.Driver.Session: Opt_SharedImplib :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowDocsOfHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowHoleConstraints :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowLoadedModules :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowMatchesOfHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowProvOfHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowTypeAppOfHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowTypeAppVarsOfHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowTypeOfHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowValidHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ShowWarnGroups :: GeneralFlag

+ GHC.Driver.Session: Opt_SimplPreInlining :: GeneralFlag

+ GHC.Driver.Session: Opt_SingleLibFolder :: GeneralFlag

+ GHC.Driver.Session: Opt_SolveConstantDicts :: GeneralFlag

+ GHC.Driver.Session: Opt_SortBySizeHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_SortBySubsumHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_SortValidHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_SpecConstr :: GeneralFlag

+ GHC.Driver.Session: Opt_SpecConstrKeen :: GeneralFlag

+ GHC.Driver.Session: Opt_Specialise :: GeneralFlag

+ GHC.Driver.Session: Opt_SpecialiseAggressively :: GeneralFlag

+ GHC.Driver.Session: Opt_SplitSections :: GeneralFlag

+ GHC.Driver.Session: Opt_StaticArgumentTransformation :: GeneralFlag

+ GHC.Driver.Session: Opt_StgCSE :: GeneralFlag

+ GHC.Driver.Session: Opt_StgLiftLams :: GeneralFlag

+ GHC.Driver.Session: Opt_StgStats :: GeneralFlag

+ GHC.Driver.Session: Opt_Strictness :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressCoercions :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressIdInfo :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressModulePrefixes :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressStgExts :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressTicks :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressTimestamps :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressTypeApplications :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressTypeSignatures :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressUnfoldings :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressUniques :: GeneralFlag

+ GHC.Driver.Session: Opt_SuppressVarKinds :: GeneralFlag

+ GHC.Driver.Session: Opt_Ticky :: GeneralFlag

+ GHC.Driver.Session: Opt_Ticky_Allocd :: GeneralFlag

+ GHC.Driver.Session: Opt_Ticky_Dyn_Thunk :: GeneralFlag

+ GHC.Driver.Session: Opt_Ticky_LNE :: GeneralFlag

+ GHC.Driver.Session: Opt_UnboxSmallStrictFields :: GeneralFlag

+ GHC.Driver.Session: Opt_UnboxStrictFields :: GeneralFlag

+ GHC.Driver.Session: Opt_UnclutterValidHoleFits :: GeneralFlag

+ GHC.Driver.Session: Opt_ValidateHie :: GeneralFlag

+ GHC.Driver.Session: Opt_VersionMacros :: GeneralFlag

+ GHC.Driver.Session: Opt_WarnAllMissedSpecs :: WarningFlag

+ GHC.Driver.Session: Opt_WarnAlternativeLayoutRuleTransitional :: WarningFlag

+ GHC.Driver.Session: Opt_WarnAutoOrphans :: WarningFlag

+ GHC.Driver.Session: Opt_WarnCPPUndef :: WarningFlag

+ GHC.Driver.Session: Opt_WarnCompatUnqualifiedImports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDeferredOutOfScopeVariables :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDeferredTypeErrors :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDeprecatedFlags :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDerivingDefaults :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDerivingTypeable :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDodgyExports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDodgyForeignImports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDodgyImports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDuplicateConstraints :: WarningFlag

+ GHC.Driver.Session: Opt_WarnDuplicateExports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnEmptyEnumerations :: WarningFlag

+ GHC.Driver.Session: Opt_WarnHiShadows :: WarningFlag

+ GHC.Driver.Session: Opt_WarnIdentities :: WarningFlag

+ GHC.Driver.Session: Opt_WarnImplicitKindVars :: WarningFlag

+ GHC.Driver.Session: Opt_WarnImplicitPrelude :: WarningFlag

+ GHC.Driver.Session: Opt_WarnInaccessibleCode :: WarningFlag

+ GHC.Driver.Session: Opt_WarnIncompletePatterns :: WarningFlag

+ GHC.Driver.Session: Opt_WarnIncompletePatternsRecUpd :: WarningFlag

+ GHC.Driver.Session: Opt_WarnIncompleteUniPatterns :: WarningFlag

+ GHC.Driver.Session: Opt_WarnInferredSafeImports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnInlineRuleShadowing :: WarningFlag

+ GHC.Driver.Session: Opt_WarnIsError :: GeneralFlag

+ GHC.Driver.Session: Opt_WarnMissedExtraSharedLib :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissedSpecs :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingDerivingStrategies :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingExportList :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingExportedSignatures :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingFields :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingHomeModules :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingImportList :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingLocalSignatures :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingMethods :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingMonadFailInstances :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingPatternSynonymSignatures :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingSafeHaskellMode :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMissingSignatures :: WarningFlag

+ GHC.Driver.Session: Opt_WarnMonomorphism :: WarningFlag

+ GHC.Driver.Session: Opt_WarnNameShadowing :: WarningFlag

+ GHC.Driver.Session: Opt_WarnNonCanonicalMonadFailInstances :: WarningFlag

+ GHC.Driver.Session: Opt_WarnNonCanonicalMonadInstances :: WarningFlag

+ GHC.Driver.Session: Opt_WarnNonCanonicalMonoidInstances :: WarningFlag

+ GHC.Driver.Session: Opt_WarnOrphans :: WarningFlag

+ GHC.Driver.Session: Opt_WarnOverflowedLiterals :: WarningFlag

+ GHC.Driver.Session: Opt_WarnOverlappingPatterns :: WarningFlag

+ GHC.Driver.Session: Opt_WarnPartialFields :: WarningFlag

+ GHC.Driver.Session: Opt_WarnPartialTypeSignatures :: WarningFlag

+ GHC.Driver.Session: Opt_WarnPrepositiveQualifiedModule :: WarningFlag

+ GHC.Driver.Session: Opt_WarnRedundantConstraints :: WarningFlag

+ GHC.Driver.Session: Opt_WarnRedundantRecordWildcards :: WarningFlag

+ GHC.Driver.Session: Opt_WarnSafe :: WarningFlag

+ GHC.Driver.Session: Opt_WarnSemigroup :: WarningFlag

+ GHC.Driver.Session: Opt_WarnSimplifiableClassConstraints :: WarningFlag

+ GHC.Driver.Session: Opt_WarnSpaceAfterBang :: WarningFlag

+ GHC.Driver.Session: Opt_WarnStarBinder :: WarningFlag

+ GHC.Driver.Session: Opt_WarnStarIsType :: WarningFlag

+ GHC.Driver.Session: Opt_WarnTabs :: WarningFlag

+ GHC.Driver.Session: Opt_WarnTrustworthySafe :: WarningFlag

+ GHC.Driver.Session: Opt_WarnTypeDefaults :: WarningFlag

+ GHC.Driver.Session: Opt_WarnTypedHoles :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnbangedStrictPatterns :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnrecognisedPragmas :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnrecognisedWarningFlags :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnsafe :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnsupportedCallingConventions :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnsupportedLlvmVersion :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUntickedPromotedConstructors :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedDoBind :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedForalls :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedImports :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedLocalBinds :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedMatches :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedPackages :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedPatternBinds :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedRecordWildcards :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedTopBinds :: WarningFlag

+ GHC.Driver.Session: Opt_WarnUnusedTypePatterns :: WarningFlag

+ GHC.Driver.Session: Opt_WarnWarningsDeprecations :: WarningFlag

+ GHC.Driver.Session: Opt_WarnWrongDoBind :: WarningFlag

+ GHC.Driver.Session: Opt_WeightlessBlocklayout :: GeneralFlag

+ GHC.Driver.Session: Opt_WholeArchiveHsLibs :: GeneralFlag

+ GHC.Driver.Session: Opt_WorkerWrapper :: GeneralFlag

+ GHC.Driver.Session: Opt_WriteHie :: GeneralFlag

+ GHC.Driver.Session: Opt_WriteInterface :: GeneralFlag

+ GHC.Driver.Session: Option :: String -> Option

+ GHC.Driver.Session: PackageArg :: String -> PackageArg

+ GHC.Driver.Session: PackageDB :: PkgDbRef -> PackageDBFlag

+ GHC.Driver.Session: PkgDbPath :: FilePath -> PkgDbRef

+ GHC.Driver.Session: PlatformConstants :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Bool -> Bool -> Int -> Integer -> Integer -> Integer -> PlatformConstants

+ GHC.Driver.Session: PlatformMisc :: String -> String -> IntegerLibrary -> Bool -> Bool -> Bool -> String -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> String -> PlatformMisc

+ GHC.Driver.Session: ProfAutoAll :: ProfAuto

+ GHC.Driver.Session: ProfAutoCalls :: ProfAuto

+ GHC.Driver.Session: ProfAutoExports :: ProfAuto

+ GHC.Driver.Session: ProfAutoTop :: ProfAuto

+ GHC.Driver.Session: Reason :: !WarningFlag -> WarnReason

+ GHC.Driver.Session: RtsOptsAll :: RtsOptsEnabled

+ GHC.Driver.Session: RtsOptsIgnore :: RtsOptsEnabled

+ GHC.Driver.Session: RtsOptsIgnoreAll :: RtsOptsEnabled

+ GHC.Driver.Session: RtsOptsNone :: RtsOptsEnabled

+ GHC.Driver.Session: RtsOptsSafeOnly :: RtsOptsEnabled

+ GHC.Driver.Session: Settings :: {-# UNPACK #-} !GhcNameVersion -> {-# UNPACK #-} !FileSettings -> Platform -> {-# UNPACK #-} !ToolSettings -> {-# UNPACK #-} !PlatformMisc -> PlatformConstants -> [(String, String)] -> Settings

+ GHC.Driver.Session: Sf_Ignore :: SafeHaskellMode

+ GHC.Driver.Session: Sf_None :: SafeHaskellMode

+ GHC.Driver.Session: Sf_Safe :: SafeHaskellMode

+ GHC.Driver.Session: Sf_SafeInferred :: SafeHaskellMode

+ GHC.Driver.Session: Sf_Trustworthy :: SafeHaskellMode

+ GHC.Driver.Session: Sf_Unsafe :: SafeHaskellMode

+ GHC.Driver.Session: SolarisLD :: [Option] -> LinkerInfo

+ GHC.Driver.Session: SystemDependent :: DynLibLoader

+ GHC.Driver.Session: TrustPackage :: String -> TrustFlag

+ GHC.Driver.Session: UnitIdArg :: UnitId -> PackageArg

+ GHC.Driver.Session: UnknownCC :: CompilerInfo

+ GHC.Driver.Session: UnknownLD :: LinkerInfo

+ GHC.Driver.Session: UserPkgDb :: PkgDbRef

+ GHC.Driver.Session: WayCustom :: String -> Way

+ GHC.Driver.Session: WayDebug :: Way

+ GHC.Driver.Session: WayDyn :: Way

+ GHC.Driver.Session: WayEventLog :: Way

+ GHC.Driver.Session: WayProf :: Way

+ GHC.Driver.Session: WayThreaded :: Way

+ GHC.Driver.Session: [avx2] :: DynFlags -> Bool

+ GHC.Driver.Session: [avx512cd] :: DynFlags -> Bool

+ GHC.Driver.Session: [avx512er] :: DynFlags -> Bool

+ GHC.Driver.Session: [avx512f] :: DynFlags -> Bool

+ GHC.Driver.Session: [avx512pf] :: DynFlags -> Bool

+ GHC.Driver.Session: [avx] :: DynFlags -> Bool

+ GHC.Driver.Session: [backEdgeBonus] :: CfgWeights -> Int

+ GHC.Driver.Session: [binBlobThreshold] :: DynFlags -> Word

+ GHC.Driver.Session: [bmiVersion] :: DynFlags -> Maybe BmiVersion

+ GHC.Driver.Session: [buildTag] :: DynFlags -> String

+ GHC.Driver.Session: [cachedPlugins] :: DynFlags -> [LoadedPlugin]

+ GHC.Driver.Session: [callWeight] :: CfgWeights -> Int

+ GHC.Driver.Session: [canGenerateDynamicToo] :: DynFlags -> IORef Bool

+ GHC.Driver.Session: [canUseColor] :: DynFlags -> Bool

+ GHC.Driver.Session: [cfgWeightInfo] :: DynFlags -> CfgWeights

+ GHC.Driver.Session: [cmdlineFrameworks] :: DynFlags -> [String]

+ GHC.Driver.Session: [cmmProcAlignment] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [colScheme] :: DynFlags -> Scheme

+ GHC.Driver.Session: [condBranchWeight] :: CfgWeights -> Int

+ GHC.Driver.Session: [debugLevel] :: DynFlags -> Int

+ GHC.Driver.Session: [depExcludeMods] :: DynFlags -> [ModuleName]

+ GHC.Driver.Session: [depIncludeCppDeps] :: DynFlags -> Bool

+ GHC.Driver.Session: [depIncludePkgDeps] :: DynFlags -> Bool

+ GHC.Driver.Session: [depMakefile] :: DynFlags -> FilePath

+ GHC.Driver.Session: [depSuffixes] :: DynFlags -> [String]

+ GHC.Driver.Session: [dirsToClean] :: DynFlags -> IORef (Map FilePath FilePath)

+ GHC.Driver.Session: [dumpDir] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [dumpFlags] :: DynFlags -> EnumSet DumpFlag

+ GHC.Driver.Session: [dumpPrefixForce] :: DynFlags -> Maybe FilePath

+ GHC.Driver.Session: [dumpPrefix] :: DynFlags -> Maybe FilePath

+ GHC.Driver.Session: [dump_action] :: DynFlags -> DumpAction

+ GHC.Driver.Session: [dylibInstallName] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [dynHiSuf] :: DynFlags -> String

+ GHC.Driver.Session: [dynLibLoader] :: DynFlags -> DynLibLoader

+ GHC.Driver.Session: [dynObjectSuf] :: DynFlags -> String

+ GHC.Driver.Session: [dynOutputFile] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [enableTimeStats] :: DynFlags -> Bool

+ GHC.Driver.Session: [extensionFlags] :: DynFlags -> EnumSet Extension

+ GHC.Driver.Session: [extensions] :: DynFlags -> [OnOff Extension]

+ GHC.Driver.Session: [fatalWarningFlags] :: DynFlags -> EnumSet WarningFlag

+ GHC.Driver.Session: [fileSettings] :: DynFlags -> {-# UNPACK #-} !FileSettings

+ GHC.Driver.Session: [fileSettings_ghcUsagePath] :: FileSettings -> FilePath

+ GHC.Driver.Session: [fileSettings_ghciUsagePath] :: FileSettings -> FilePath

+ GHC.Driver.Session: [fileSettings_globalPackageDatabase] :: FileSettings -> FilePath

+ GHC.Driver.Session: [fileSettings_tmpDir] :: FileSettings -> String

+ GHC.Driver.Session: [fileSettings_toolDir] :: FileSettings -> Maybe FilePath

+ GHC.Driver.Session: [fileSettings_topDir] :: FileSettings -> FilePath

+ GHC.Driver.Session: [filesToClean] :: DynFlags -> IORef FilesToClean

+ GHC.Driver.Session: [flagSpecAction] :: FlagSpec flag -> TurnOnFlag -> DynP ()

+ GHC.Driver.Session: [flagSpecFlag] :: FlagSpec flag -> flag

+ GHC.Driver.Session: [flagSpecGhcMode] :: FlagSpec flag -> GhcFlagMode

+ GHC.Driver.Session: [flagSpecName] :: FlagSpec flag -> String

+ GHC.Driver.Session: [floatLamArgs] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [flushErr] :: DynFlags -> FlushErr

+ GHC.Driver.Session: [flushOut] :: DynFlags -> FlushOut

+ GHC.Driver.Session: [frameworkPaths] :: DynFlags -> [String]

+ GHC.Driver.Session: [frontendPluginOpts] :: DynFlags -> [String]

+ GHC.Driver.Session: [ftcCurrentModule] :: FilesToClean -> !Set FilePath

+ GHC.Driver.Session: [ftcGhcSession] :: FilesToClean -> !Set FilePath

+ GHC.Driver.Session: [generalFlags] :: DynFlags -> EnumSet GeneralFlag

+ GHC.Driver.Session: [generatedDumps] :: DynFlags -> IORef (Set FilePath)

+ GHC.Driver.Session: [ghcHeapSize] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [ghcLink] :: DynFlags -> GhcLink

+ GHC.Driver.Session: [ghcMode] :: DynFlags -> GhcMode

+ GHC.Driver.Session: [ghcNameVersion] :: DynFlags -> {-# UNPACK #-} !GhcNameVersion

+ GHC.Driver.Session: [ghcNameVersion_programName] :: GhcNameVersion -> String

+ GHC.Driver.Session: [ghcNameVersion_projectVersion] :: GhcNameVersion -> String

+ GHC.Driver.Session: [ghcVersionFile] :: DynFlags -> Maybe FilePath

+ GHC.Driver.Session: [ghciHistSize] :: DynFlags -> Int

+ GHC.Driver.Session: [ghciScripts] :: DynFlags -> [String]

+ GHC.Driver.Session: [haddockOptions] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [hcSuf] :: DynFlags -> String

+ GHC.Driver.Session: [hiDir] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [hiSuf] :: DynFlags -> String

+ GHC.Driver.Session: [hieDir] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [hieSuf] :: DynFlags -> String

+ GHC.Driver.Session: [historySize] :: DynFlags -> Int

+ GHC.Driver.Session: [hooks] :: DynFlags -> Hooks

+ GHC.Driver.Session: [hpcDir] :: DynFlags -> String

+ GHC.Driver.Session: [hscTarget] :: DynFlags -> HscTarget

+ GHC.Driver.Session: [ignorePackageFlags] :: DynFlags -> [IgnorePackageFlag]

+ GHC.Driver.Session: [importPaths] :: DynFlags -> [FilePath]

+ GHC.Driver.Session: [includePathsGlobal] :: IncludeSpecs -> [String]

+ GHC.Driver.Session: [includePathsQuote] :: IncludeSpecs -> [String]

+ GHC.Driver.Session: [includePaths] :: DynFlags -> IncludeSpecs

+ GHC.Driver.Session: [incoherentOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [infoTablePenalty] :: CfgWeights -> Int

+ GHC.Driver.Session: [initialUnique] :: DynFlags -> Int

+ GHC.Driver.Session: [inlineCheck] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [integerLibrary] :: DynFlags -> IntegerLibrary

+ GHC.Driver.Session: [interactivePrint] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [lAttributes] :: LlvmTarget -> [String]

+ GHC.Driver.Session: [lCPU] :: LlvmTarget -> String

+ GHC.Driver.Session: [lDataLayout] :: LlvmTarget -> String

+ GHC.Driver.Session: [language] :: DynFlags -> Maybe Language

+ GHC.Driver.Session: [ldInputs] :: DynFlags -> [Option]

+ GHC.Driver.Session: [liberateCaseThreshold] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [libraryPaths] :: DynFlags -> [String]

+ GHC.Driver.Session: [liftLamsKnown] :: DynFlags -> Bool

+ GHC.Driver.Session: [liftLamsNonRecArgs] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [liftLamsRecArgs] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [likelyCondWeight] :: CfgWeights -> Int

+ GHC.Driver.Session: [llvmConfig] :: DynFlags -> LlvmConfig

+ GHC.Driver.Session: [llvmPasses] :: LlvmConfig -> [(Int, String)]

+ GHC.Driver.Session: [llvmTargets] :: LlvmConfig -> [(String, LlvmTarget)]

+ GHC.Driver.Session: [log_action] :: DynFlags -> LogAction

+ GHC.Driver.Session: [mainFunIs] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [mainModIs] :: DynFlags -> Module

+ GHC.Driver.Session: [maxErrors] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [maxInlineAllocSize] :: DynFlags -> Int

+ GHC.Driver.Session: [maxInlineMemcpyInsns] :: DynFlags -> Int

+ GHC.Driver.Session: [maxInlineMemsetInsns] :: DynFlags -> Int

+ GHC.Driver.Session: [maxPmCheckModels] :: DynFlags -> Int

+ GHC.Driver.Session: [maxRefHoleFits] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [maxRelevantBinds] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [maxSimplIterations] :: DynFlags -> Int

+ GHC.Driver.Session: [maxUncoveredPatterns] :: DynFlags -> Int

+ GHC.Driver.Session: [maxValidHoleFits] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [maxWorkerArgs] :: DynFlags -> Int

+ GHC.Driver.Session: [modRenamingWithImplicit] :: ModRenaming -> Bool

+ GHC.Driver.Session: [modRenamings] :: ModRenaming -> [(ModuleName, ModuleName)]

+ GHC.Driver.Session: [newDerivOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [nextTempSuffix] :: DynFlags -> IORef Int

+ GHC.Driver.Session: [nextWrapperNum] :: DynFlags -> IORef (ModuleEnv Int)

+ GHC.Driver.Session: [objectDir] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [objectSuf] :: DynFlags -> String

+ GHC.Driver.Session: [optLevel] :: DynFlags -> Int

+ GHC.Driver.Session: [outputFile] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [outputHi] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [overlapInstLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [packageDBFlags] :: DynFlags -> [PackageDBFlag]

+ GHC.Driver.Session: [packageEnv] :: DynFlags -> Maybe FilePath

+ GHC.Driver.Session: [packageFlags] :: DynFlags -> [PackageFlag]

+ GHC.Driver.Session: [parMakeCount] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [pc_AP_STACK_SPLIM] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_BITMAP_BITS_SHIFT] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_BLOCKS_PER_MBLOCK] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_BLOCK_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_CINT_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_CLONG_LONG_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_CLONG_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_CONTROL_GROUP_CONST_291] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_DOUBLE_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_DYNAMIC_BY_DEFAULT] :: PlatformConstants -> Bool

+ GHC.Driver.Session: [pc_ILDV_CREATE_MASK] :: PlatformConstants -> Integer

+ GHC.Driver.Session: [pc_ILDV_STATE_CREATE] :: PlatformConstants -> Integer

+ GHC.Driver.Session: [pc_ILDV_STATE_USE] :: PlatformConstants -> Integer

+ GHC.Driver.Session: [pc_LDV_SHIFT] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_CHARLIKE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Double_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Float_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_INTLIKE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Long_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Real_Double_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Real_Float_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Real_Long_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Real_Vanilla_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Real_XMM_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_SPEC_AP_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_SPEC_SELECTEE_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_Vanilla_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MAX_XMM_REG] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MIN_CHARLIKE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MIN_INTLIKE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MIN_PAYLOAD_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_MUT_ARR_PTRS_CARD_BITS] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_Capability_r] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_CostCentreStack_mem_alloc] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_CostCentreStack_scc_count] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgArrBytes_bytes] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgEntCounter_allocd] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgEntCounter_allocs] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgEntCounter_entry_count] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgEntCounter_link] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgEntCounter_registeredp] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgHeader_ccs] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgHeader_ldvw] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgMutArrPtrs_ptrs] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgMutArrPtrs_size] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rCCCS] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rCurrentNursery] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rCurrentTSO] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rD1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rD2] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rD3] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rD4] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rD5] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rD6] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rF1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rF2] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rF3] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rF4] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rF5] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rF6] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rHpAlloc] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rHpLim] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rHp] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rL1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR10] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR2] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR3] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR4] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR5] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR6] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR7] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR8] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rR9] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rSpLim] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rSp] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rXMM1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rXMM2] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rXMM3] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rXMM4] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rXMM5] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rXMM6] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rYMM1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rYMM2] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rYMM3] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rYMM4] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rYMM5] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rYMM6] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rZMM1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rZMM2] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rZMM3] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rZMM4] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rZMM5] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgRegTable_rZMM6] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgSmallMutArrPtrs_ptrs] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgStack_sp] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgStack_stack] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgTSO_alloc_limit] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgTSO_cccs] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgTSO_stackobj] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_StgUpdateFrame_updatee] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_bdescr_blocks] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_bdescr_flags] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_bdescr_free] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_bdescr_start] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_stgEagerBlackholeInfo] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_stgGCEnter1] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_OFFSET_stgGCFun] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_PROF_HDR_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_REP_CostCentreStack_mem_alloc] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_REP_CostCentreStack_scc_count] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_REP_StgEntCounter_allocd] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_REP_StgEntCounter_allocs] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_REP_StgFunInfoExtraFwd_arity] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_REP_StgFunInfoExtraRev_arity] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_RESERVED_C_STACK_BYTES] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_RESERVED_STACK_WORDS] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_CostCentreStack] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_StgArrBytes_NoHdr] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_StgFunInfoExtraRev] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_StgMutArrPtrs_NoHdr] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_StgSMPThunkHeader] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_StgSmallMutArrPtrs_NoHdr] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_SIZEOF_StgUpdateFrame_NoHdr] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_STD_HDR_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_TAG_BITS] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_TICKY_BIN_COUNT] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pc_WORDS_BIGENDIAN] :: PlatformConstants -> Bool

+ GHC.Driver.Session: [pc_WORD_SIZE] :: PlatformConstants -> Int

+ GHC.Driver.Session: [pkgDatabase] :: DynFlags -> Maybe [PackageDatabase]

+ GHC.Driver.Session: [pkgState] :: DynFlags -> PackageState

+ GHC.Driver.Session: [pkgTrustOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [platformConstants] :: DynFlags -> PlatformConstants

+ GHC.Driver.Session: [platformMisc] :: DynFlags -> {-# UNPACK #-} !PlatformMisc

+ GHC.Driver.Session: [platformMisc_ghcDebugged] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_ghcRTSWays] :: PlatformMisc -> String

+ GHC.Driver.Session: [platformMisc_ghcRtsWithLibdw] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_ghcThreaded] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_ghcWithInterpreter] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_ghcWithNativeCodeGen] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_ghcWithSMP] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_integerLibraryType] :: PlatformMisc -> IntegerLibrary

+ GHC.Driver.Session: [platformMisc_integerLibrary] :: PlatformMisc -> String

+ GHC.Driver.Session: [platformMisc_leadingUnderscore] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_libFFI] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_llvmTarget] :: PlatformMisc -> String

+ GHC.Driver.Session: [platformMisc_tablesNextToCode] :: PlatformMisc -> Bool

+ GHC.Driver.Session: [platformMisc_targetPlatformString] :: PlatformMisc -> String

+ GHC.Driver.Session: [pluginModNameOpts] :: DynFlags -> [(ModuleName, String)]

+ GHC.Driver.Session: [pluginModNames] :: DynFlags -> [ModuleName]

+ GHC.Driver.Session: [pluginPackageFlags] :: DynFlags -> [PackageFlag]

+ GHC.Driver.Session: [pprCols] :: DynFlags -> Int

+ GHC.Driver.Session: [pprUserLength] :: DynFlags -> Int

+ GHC.Driver.Session: [profAuto] :: DynFlags -> ProfAuto

+ GHC.Driver.Session: [rawSettings] :: DynFlags -> [(String, String)]

+ GHC.Driver.Session: [reductionDepth] :: DynFlags -> IntWithInf

+ GHC.Driver.Session: [refLevelHoleFits] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [reverseErrors] :: DynFlags -> Bool

+ GHC.Driver.Session: [rtccInfo] :: DynFlags -> IORef (Maybe CompilerInfo)

+ GHC.Driver.Session: [rtldInfo] :: DynFlags -> IORef (Maybe LinkerInfo)

+ GHC.Driver.Session: [rtsOptsEnabled] :: DynFlags -> RtsOptsEnabled

+ GHC.Driver.Session: [rtsOptsSuggestions] :: DynFlags -> Bool

+ GHC.Driver.Session: [rtsOpts] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [ruleCheck] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [sFileSettings] :: Settings -> {-# UNPACK #-} !FileSettings

+ GHC.Driver.Session: [sGhcNameVersion] :: Settings -> {-# UNPACK #-} !GhcNameVersion

+ GHC.Driver.Session: [sPlatformConstants] :: Settings -> PlatformConstants

+ GHC.Driver.Session: [sPlatformMisc] :: Settings -> {-# UNPACK #-} !PlatformMisc

+ GHC.Driver.Session: [sRawSettings] :: Settings -> [(String, String)]

+ GHC.Driver.Session: [sTargetPlatform] :: Settings -> Platform

+ GHC.Driver.Session: [sToolSettings] :: Settings -> {-# UNPACK #-} !ToolSettings

+ GHC.Driver.Session: [safeHaskell] :: DynFlags -> SafeHaskellMode

+ GHC.Driver.Session: [safeInfer] :: DynFlags -> Bool

+ GHC.Driver.Session: [safeInferred] :: DynFlags -> Bool

+ GHC.Driver.Session: [simplPhases] :: DynFlags -> Int

+ GHC.Driver.Session: [simplTickFactor] :: DynFlags -> Int

+ GHC.Driver.Session: [solverIterations] :: DynFlags -> IntWithInf

+ GHC.Driver.Session: [specConstrCount] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [specConstrRecursive] :: DynFlags -> Int

+ GHC.Driver.Session: [specConstrThreshold] :: DynFlags -> Maybe Int

+ GHC.Driver.Session: [splitInfo] :: DynFlags -> Maybe (String, Int)

+ GHC.Driver.Session: [sseVersion] :: DynFlags -> Maybe SseVersion

+ GHC.Driver.Session: [staticPlugins] :: DynFlags -> [StaticPlugin]

+ GHC.Driver.Session: [strictnessBefore] :: DynFlags -> [Int]

+ GHC.Driver.Session: [stubDir] :: DynFlags -> Maybe String

+ GHC.Driver.Session: [switchWeight] :: CfgWeights -> Int

+ GHC.Driver.Session: [targetPlatform] :: DynFlags -> Platform

+ GHC.Driver.Session: [thOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [thisComponentId_] :: DynFlags -> Maybe ComponentId

+ GHC.Driver.Session: [thisInstalledUnitId] :: DynFlags -> InstalledUnitId

+ GHC.Driver.Session: [thisUnitIdInsts_] :: DynFlags -> Maybe [(ModuleName, Module)]

+ GHC.Driver.Session: [toolSettings] :: DynFlags -> {-# UNPACK #-} !ToolSettings

+ GHC.Driver.Session: [trace_action] :: DynFlags -> TraceAction

+ GHC.Driver.Session: [trustFlags] :: DynFlags -> [TrustFlag]

+ GHC.Driver.Session: [trustworthyOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [ufCreationThreshold] :: DynFlags -> Int

+ GHC.Driver.Session: [ufDearOp] :: DynFlags -> Int

+ GHC.Driver.Session: [ufDictDiscount] :: DynFlags -> Int

+ GHC.Driver.Session: [ufFunAppDiscount] :: DynFlags -> Int

+ GHC.Driver.Session: [ufKeenessFactor] :: DynFlags -> Float

+ GHC.Driver.Session: [ufUseThreshold] :: DynFlags -> Int

+ GHC.Driver.Session: [ufVeryAggressive] :: DynFlags -> Bool

+ GHC.Driver.Session: [uncondWeight] :: CfgWeights -> Int

+ GHC.Driver.Session: [uniqueIncrement] :: DynFlags -> Int

+ GHC.Driver.Session: [unlikelyCondWeight] :: CfgWeights -> Int

+ GHC.Driver.Session: [useColor] :: DynFlags -> OverridingBool

+ GHC.Driver.Session: [useUnicode] :: DynFlags -> Bool

+ GHC.Driver.Session: [verbosity] :: DynFlags -> Int

+ GHC.Driver.Session: [warnSafeOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [warnUnsafeOnLoc] :: DynFlags -> SrcSpan

+ GHC.Driver.Session: [warningFlags] :: DynFlags -> EnumSet WarningFlag

+ GHC.Driver.Session: [ways] :: DynFlags -> [Way]

+ GHC.Driver.Session: aP_STACK_SPLIM :: DynFlags -> Int

+ GHC.Driver.Session: addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs

+ GHC.Driver.Session: addPluginModuleName :: String -> DynFlags -> DynFlags

+ GHC.Driver.Session: addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs

+ GHC.Driver.Session: addWay' :: Way -> DynFlags -> DynFlags

+ GHC.Driver.Session: allNonDeprecatedFlags :: [String]

+ GHC.Driver.Session: bITMAP_BITS_SHIFT :: DynFlags -> Int

+ GHC.Driver.Session: bLOCKS_PER_MBLOCK :: DynFlags -> Int

+ GHC.Driver.Session: bLOCK_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: bLOCK_SIZE_W :: DynFlags -> Int

+ GHC.Driver.Session: backendMaintainsCfg :: DynFlags -> Bool

+ GHC.Driver.Session: cINT_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: cLONG_LONG_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: cLONG_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: cONTROL_GROUP_CONST_291 :: DynFlags -> Int

+ GHC.Driver.Session: canonicalizeHomeModule :: DynFlags -> ModuleName -> Module

+ GHC.Driver.Session: canonicalizeModuleIfHome :: DynFlags -> Module -> Module

+ GHC.Driver.Session: class ContainsDynFlags t

+ GHC.Driver.Session: class HasDynFlags m

+ GHC.Driver.Session: compilerInfo :: DynFlags -> [(String, String)]

+ GHC.Driver.Session: dOUBLE_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: dYNAMIC_BY_DEFAULT :: DynFlags -> Bool

+ GHC.Driver.Session: data CfgWeights

+ GHC.Driver.Session: data CompilerInfo

+ GHC.Driver.Session: data DumpFlag

+ GHC.Driver.Session: data DynFlags

+ GHC.Driver.Session: data DynLibLoader

+ GHC.Driver.Session: data FileSettings

+ GHC.Driver.Session: data FilesToClean

+ GHC.Driver.Session: data FlagSpec flag

+ GHC.Driver.Session: data GeneralFlag

+ GHC.Driver.Session: data GhcLink

+ GHC.Driver.Session: data GhcMode

+ GHC.Driver.Session: data GhcNameVersion

+ GHC.Driver.Session: data HscTarget

+ GHC.Driver.Session: data IncludeSpecs

+ GHC.Driver.Session: data IntegerLibrary

+ GHC.Driver.Session: data Language

+ GHC.Driver.Session: data LinkerInfo

+ GHC.Driver.Session: data LlvmConfig

+ GHC.Driver.Session: data LlvmTarget

+ GHC.Driver.Session: data ModRenaming

+ GHC.Driver.Session: data Option

+ GHC.Driver.Session: data PackageArg

+ GHC.Driver.Session: data PackageDBFlag

+ GHC.Driver.Session: data PackageFlag

+ GHC.Driver.Session: data PkgDbRef

+ GHC.Driver.Session: data PlatformConstants

+ GHC.Driver.Session: data PlatformMisc

+ GHC.Driver.Session: data ProfAuto

+ GHC.Driver.Session: data RtsOptsEnabled

+ GHC.Driver.Session: data SafeHaskellMode

+ GHC.Driver.Session: data Settings

+ GHC.Driver.Session: data TrustFlag

+ GHC.Driver.Session: data WarnReason

+ GHC.Driver.Session: data WarningFlag

+ GHC.Driver.Session: data Way

+ GHC.Driver.Session: defaultDynFlags :: Settings -> LlvmConfig -> DynFlags

+ GHC.Driver.Session: defaultFatalMessager :: FatalMessager

+ GHC.Driver.Session: defaultFlushErr :: FlushErr

+ GHC.Driver.Session: defaultFlushOut :: FlushOut

+ GHC.Driver.Session: defaultLogAction :: LogAction

+ GHC.Driver.Session: defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()

+ GHC.Driver.Session: defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()

+ GHC.Driver.Session: defaultObjectTarget :: DynFlags -> HscTarget

+ GHC.Driver.Session: defaultWays :: Settings -> [Way]

+ GHC.Driver.Session: dopt :: DumpFlag -> DynFlags -> Bool

+ GHC.Driver.Session: dopt_set :: DynFlags -> DumpFlag -> DynFlags

+ GHC.Driver.Session: dopt_unset :: DynFlags -> DumpFlag -> DynFlags

+ GHC.Driver.Session: dynFlagDependencies :: DynFlags -> [ModuleName]

+ GHC.Driver.Session: dynamicGhc :: Bool

+ GHC.Driver.Session: dynamicOutputFile :: DynFlags -> FilePath -> FilePath

+ GHC.Driver.Session: dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags

+ GHC.Driver.Session: emptyFilesToClean :: FilesToClean

+ GHC.Driver.Session: extraGccViaCFlags :: DynFlags -> [String]

+ GHC.Driver.Session: extractDynFlags :: ContainsDynFlags t => t -> DynFlags

+ GHC.Driver.Session: fFlags :: [FlagSpec GeneralFlag]

+ GHC.Driver.Session: fLangFlags :: [FlagSpec Extension]

+ GHC.Driver.Session: flagsAll :: [Flag (CmdLineP DynFlags)]

+ GHC.Driver.Session: flagsDynamic :: [Flag (CmdLineP DynFlags)]

+ GHC.Driver.Session: flagsForCompletion :: Bool -> [String]

+ GHC.Driver.Session: flagsPackage :: [Flag (CmdLineP DynFlags)]

+ GHC.Driver.Session: flattenIncludes :: IncludeSpecs -> [String]

+ GHC.Driver.Session: getDynFlags :: HasDynFlags m => m DynFlags

+ GHC.Driver.Session: getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]

+ GHC.Driver.Session: getVerbFlags :: DynFlags -> [String]

+ GHC.Driver.Session: ghcUsagePath :: DynFlags -> FilePath

+ GHC.Driver.Session: ghciUsagePath :: DynFlags -> FilePath

+ GHC.Driver.Session: glasgowExtsFlags :: [Extension]

+ GHC.Driver.Session: globalPackageDatabasePath :: DynFlags -> FilePath

+ GHC.Driver.Session: gopt :: GeneralFlag -> DynFlags -> Bool

+ GHC.Driver.Session: gopt_set :: DynFlags -> GeneralFlag -> DynFlags

+ GHC.Driver.Session: gopt_unset :: DynFlags -> GeneralFlag -> DynFlags

+ GHC.Driver.Session: hasNoDebugOutput :: DynFlags -> Bool

+ GHC.Driver.Session: hasNoOptCoercion :: DynFlags -> Bool

+ GHC.Driver.Session: hasNoStateHack :: DynFlags -> Bool

+ GHC.Driver.Session: hasPprDebug :: DynFlags -> Bool

+ GHC.Driver.Session: iLDV_CREATE_MASK :: DynFlags -> Integer

+ GHC.Driver.Session: iLDV_STATE_CREATE :: DynFlags -> Integer

+ GHC.Driver.Session: iLDV_STATE_USE :: DynFlags -> Integer

+ GHC.Driver.Session: ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a

+ GHC.Driver.Session: initDynFlags :: DynFlags -> IO DynFlags

+ GHC.Driver.Session: initSDocContext :: DynFlags -> PprStyle -> SDocContext

+ GHC.Driver.Session: instance (GHC.Base.Monad m, GHC.Driver.Session.HasDynFlags m) => GHC.Driver.Session.HasDynFlags (Control.Monad.Trans.Except.ExceptT e m)

+ GHC.Driver.Session: instance (GHC.Base.Monad m, GHC.Driver.Session.HasDynFlags m) => GHC.Driver.Session.HasDynFlags (Control.Monad.Trans.Maybe.MaybeT m)

+ GHC.Driver.Session: instance (GHC.Base.Monad m, GHC.Driver.Session.HasDynFlags m) => GHC.Driver.Session.HasDynFlags (Control.Monad.Trans.Reader.ReaderT a m)

+ GHC.Driver.Session: instance (GHC.Base.Monoid a, GHC.Base.Monad m, GHC.Driver.Session.HasDynFlags m) => GHC.Driver.Session.HasDynFlags (Control.Monad.Trans.Writer.Lazy.WriterT a m)

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.BmiVersion

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.CompilerInfo

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.Deprecation

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.DumpFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.DynLibLoader

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.GeneralFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.GhcLink

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.GhcMode

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.HscTarget

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.IgnorePackageFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.Language

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.LinkerInfo

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.ModRenaming

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.PackageArg

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.PackageDBFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.PackageFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.PkgDbRef

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.ProfAuto

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.SafeHaskellMode

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.SseVersion

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.TrustFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.WarningFlag

+ GHC.Driver.Session: instance GHC.Classes.Eq GHC.Driver.Session.Way

+ GHC.Driver.Session: instance GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Driver.Session.OnOff a)

+ GHC.Driver.Session: instance GHC.Classes.Ord GHC.Driver.Session.BmiVersion

+ GHC.Driver.Session: instance GHC.Classes.Ord GHC.Driver.Session.Deprecation

+ GHC.Driver.Session: instance GHC.Classes.Ord GHC.Driver.Session.SseVersion

+ GHC.Driver.Session: instance GHC.Classes.Ord GHC.Driver.Session.Way

+ GHC.Driver.Session: instance GHC.Enum.Enum GHC.Driver.Session.DumpFlag

+ GHC.Driver.Session: instance GHC.Enum.Enum GHC.Driver.Session.GeneralFlag

+ GHC.Driver.Session: instance GHC.Enum.Enum GHC.Driver.Session.Language

+ GHC.Driver.Session: instance GHC.Enum.Enum GHC.Driver.Session.ProfAuto

+ GHC.Driver.Session: instance GHC.Enum.Enum GHC.Driver.Session.WarningFlag

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.DumpFlag

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.GeneralFlag

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.GhcLink

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.HscTarget

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.IncludeSpecs

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.Language

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.PackageArg

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.RtsOptsEnabled

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.SafeHaskellMode

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.WarnReason

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.WarningFlag

+ GHC.Driver.Session: instance GHC.Show.Show GHC.Driver.Session.Way

+ GHC.Driver.Session: instance GHC.Show.Show a => GHC.Show.Show (GHC.Driver.Session.OnOff a)

+ GHC.Driver.Session: instance Json.ToJson GHC.Driver.Session.WarnReason

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.GhcMode

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.Language

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.ModRenaming

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.PackageArg

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.PackageFlag

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.SafeHaskellMode

+ GHC.Driver.Session: instance Outputable.Outputable GHC.Driver.Session.WarnReason

+ GHC.Driver.Session: instance Outputable.Outputable a => Outputable.Outputable (GHC.Driver.Session.OnOff a)

+ GHC.Driver.Session: interpWays :: [Way]

+ GHC.Driver.Session: interpreterDynamic :: DynFlags -> Bool

+ GHC.Driver.Session: interpreterProfiled :: DynFlags -> Bool

+ GHC.Driver.Session: isAvx2Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: isAvx512cdEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: isAvx512erEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: isAvx512fEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: isAvx512pfEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: isAvxEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: isBmi2Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: isBmiEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: isNoLink :: GhcLink -> Bool

+ GHC.Driver.Session: isObjectTarget :: HscTarget -> Bool

+ GHC.Driver.Session: isOneShot :: GhcMode -> Bool

+ GHC.Driver.Session: isSse2Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: isSse4_2Enabled :: DynFlags -> Bool

+ GHC.Driver.Session: isSseEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: lDV_SHIFT :: DynFlags -> Int

+ GHC.Driver.Session: lang_set :: DynFlags -> Maybe Language -> DynFlags

+ GHC.Driver.Session: languageExtensions :: Maybe Language -> [Extension]

+ GHC.Driver.Session: mAX_CHARLIKE :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Double_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Float_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_INTLIKE :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Long_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_PTR_TAG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Real_Double_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Real_Float_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Real_Long_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Real_Vanilla_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Real_XMM_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_SPEC_AP_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: mAX_SPEC_SELECTEE_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: mAX_Vanilla_REG :: DynFlags -> Int

+ GHC.Driver.Session: mAX_XMM_REG :: DynFlags -> Int

+ GHC.Driver.Session: mIN_CHARLIKE :: DynFlags -> Int

+ GHC.Driver.Session: mIN_INTLIKE :: DynFlags -> Int

+ GHC.Driver.Session: mIN_PAYLOAD_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: mUT_ARR_PTRS_CARD_BITS :: DynFlags -> Int

+ GHC.Driver.Session: makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])

+ GHC.Driver.Session: mkBuildTag :: [Way] -> String

+ GHC.Driver.Session: newtype FlushErr

+ GHC.Driver.Session: newtype FlushOut

+ GHC.Driver.Session: newtype IgnorePackageFlag

+ GHC.Driver.Session: oFFSET_Capability_r :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_CostCentreStack_mem_alloc :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_CostCentreStack_scc_count :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgArrBytes_bytes :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgEntCounter_allocd :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgEntCounter_allocs :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgEntCounter_entry_count :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgEntCounter_link :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgEntCounter_registeredp :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgFunInfoExtraFwd_arity :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgFunInfoExtraRev_arity :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgHeader_ccs :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgHeader_ldvw :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgMutArrPtrs_ptrs :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgMutArrPtrs_size :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rCCCS :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rCurrentNursery :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rCurrentTSO :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rD1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rD2 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rD3 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rD4 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rD5 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rD6 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rF1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rF2 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rF3 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rF4 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rF5 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rF6 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rHp :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rHpAlloc :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rHpLim :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rL1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR10 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR2 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR3 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR4 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR5 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR6 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR7 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR8 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rR9 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rSp :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rSpLim :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rXMM1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rXMM2 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rXMM3 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rXMM4 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rXMM5 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rXMM6 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rYMM1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rYMM2 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rYMM3 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rYMM4 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rYMM5 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rYMM6 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rZMM1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rZMM2 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rZMM3 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rZMM4 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rZMM5 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgRegTable_rZMM6 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgSmallMutArrPtrs_ptrs :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgStack_sp :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgStack_stack :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgTSO_alloc_limit :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgTSO_cccs :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgTSO_stackobj :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_StgUpdateFrame_updatee :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_bdescr_blocks :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_bdescr_flags :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_bdescr_free :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_bdescr_start :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_stgEagerBlackholeInfo :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_stgGCEnter1 :: DynFlags -> Int

+ GHC.Driver.Session: oFFSET_stgGCFun :: DynFlags -> Int

+ GHC.Driver.Session: opt_F :: DynFlags -> [String]

+ GHC.Driver.Session: opt_L :: DynFlags -> [String]

+ GHC.Driver.Session: opt_P :: DynFlags -> [String]

+ GHC.Driver.Session: opt_P_signature :: DynFlags -> ([String], Fingerprint)

+ GHC.Driver.Session: opt_a :: DynFlags -> [String]

+ GHC.Driver.Session: opt_c :: DynFlags -> [String]

+ GHC.Driver.Session: opt_cxx :: DynFlags -> [String]

+ GHC.Driver.Session: opt_i :: DynFlags -> [String]

+ GHC.Driver.Session: opt_l :: DynFlags -> [String]

+ GHC.Driver.Session: opt_lc :: DynFlags -> [String]

+ GHC.Driver.Session: opt_lcc :: DynFlags -> [String]

+ GHC.Driver.Session: opt_lo :: DynFlags -> [String]

+ GHC.Driver.Session: opt_windres :: DynFlags -> [String]

+ GHC.Driver.Session: optimisationFlags :: EnumSet GeneralFlag

+ GHC.Driver.Session: pROF_HDR_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: packageFlagsChanged :: DynFlags -> DynFlags -> Bool

+ GHC.Driver.Session: packageTrustOn :: DynFlags -> Bool

+ GHC.Driver.Session: parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])

+ GHC.Driver.Session: parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])

+ GHC.Driver.Session: parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])

+ GHC.Driver.Session: pgm_F :: DynFlags -> String

+ GHC.Driver.Session: pgm_L :: DynFlags -> String

+ GHC.Driver.Session: pgm_P :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_T :: DynFlags -> String

+ GHC.Driver.Session: pgm_a :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_ar :: DynFlags -> String

+ GHC.Driver.Session: pgm_c :: DynFlags -> String

+ GHC.Driver.Session: pgm_dll :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_i :: DynFlags -> String

+ GHC.Driver.Session: pgm_l :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_lc :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_lcc :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_libtool :: DynFlags -> String

+ GHC.Driver.Session: pgm_lo :: DynFlags -> (String, [Option])

+ GHC.Driver.Session: pgm_ranlib :: DynFlags -> String

+ GHC.Driver.Session: pgm_windres :: DynFlags -> String

+ GHC.Driver.Session: picCCOpts :: DynFlags -> [String]

+ GHC.Driver.Session: picPOpts :: DynFlags -> [String]

+ GHC.Driver.Session: positionIndependent :: DynFlags -> Bool

+ GHC.Driver.Session: programName :: DynFlags -> String

+ GHC.Driver.Session: projectVersion :: DynFlags -> String

+ GHC.Driver.Session: putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()

+ GHC.Driver.Session: rESERVED_C_STACK_BYTES :: DynFlags -> Int

+ GHC.Driver.Session: rESERVED_STACK_WORDS :: DynFlags -> Int

+ GHC.Driver.Session: rtsIsProfiled :: Bool

+ GHC.Driver.Session: sExtraGccViaCFlags :: Settings -> [String]

+ GHC.Driver.Session: sGccSupportsNoPie :: Settings -> Bool

+ GHC.Driver.Session: sGhcDebugged :: Settings -> Bool

+ GHC.Driver.Session: sGhcRTSWays :: Settings -> String

+ GHC.Driver.Session: sGhcRtsWithLibdw :: Settings -> Bool

+ GHC.Driver.Session: sGhcThreaded :: Settings -> Bool

+ GHC.Driver.Session: sGhcUsagePath :: Settings -> FilePath

+ GHC.Driver.Session: sGhcWithInterpreter :: Settings -> Bool

+ GHC.Driver.Session: sGhcWithNativeCodeGen :: Settings -> Bool

+ GHC.Driver.Session: sGhcWithSMP :: Settings -> Bool

+ GHC.Driver.Session: sGhciUsagePath :: Settings -> FilePath

+ GHC.Driver.Session: sGlobalPackageDatabasePath :: Settings -> FilePath

+ GHC.Driver.Session: sIZEOF_CostCentreStack :: DynFlags -> Int

+ GHC.Driver.Session: sIZEOF_StgArrBytes_NoHdr :: DynFlags -> Int

+ GHC.Driver.Session: sIZEOF_StgFunInfoExtraRev :: DynFlags -> Int

+ GHC.Driver.Session: sIZEOF_StgMutArrPtrs_NoHdr :: DynFlags -> Int

+ GHC.Driver.Session: sIZEOF_StgSMPThunkHeader :: DynFlags -> Int

+ GHC.Driver.Session: sIZEOF_StgSmallMutArrPtrs_NoHdr :: DynFlags -> Int

+ GHC.Driver.Session: sIZEOF_StgUpdateFrame_NoHdr :: DynFlags -> Int

+ GHC.Driver.Session: sIntegerLibrary :: Settings -> String

+ GHC.Driver.Session: sIntegerLibraryType :: Settings -> IntegerLibrary

+ GHC.Driver.Session: sLdIsGnuLd :: Settings -> Bool

+ GHC.Driver.Session: sLdSupportsBuildId :: Settings -> Bool

+ GHC.Driver.Session: sLdSupportsCompactUnwind :: Settings -> Bool

+ GHC.Driver.Session: sLdSupportsFilelist :: Settings -> Bool

+ GHC.Driver.Session: sLeadingUnderscore :: Settings -> Bool

+ GHC.Driver.Session: sLibFFI :: Settings -> Bool

+ GHC.Driver.Session: sOpt_F :: Settings -> [String]

+ GHC.Driver.Session: sOpt_L :: Settings -> [String]

+ GHC.Driver.Session: sOpt_P :: Settings -> [String]

+ GHC.Driver.Session: sOpt_P_fingerprint :: Settings -> Fingerprint

+ GHC.Driver.Session: sOpt_a :: Settings -> [String]

+ GHC.Driver.Session: sOpt_c :: Settings -> [String]

+ GHC.Driver.Session: sOpt_cxx :: Settings -> [String]

+ GHC.Driver.Session: sOpt_i :: Settings -> [String]

+ GHC.Driver.Session: sOpt_l :: Settings -> [String]

+ GHC.Driver.Session: sOpt_lc :: Settings -> [String]

+ GHC.Driver.Session: sOpt_lcc :: Settings -> [String]

+ GHC.Driver.Session: sOpt_lo :: Settings -> [String]

+ GHC.Driver.Session: sOpt_windres :: Settings -> [String]

+ GHC.Driver.Session: sPgm_F :: Settings -> String

+ GHC.Driver.Session: sPgm_L :: Settings -> String

+ GHC.Driver.Session: sPgm_P :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_T :: Settings -> String

+ GHC.Driver.Session: sPgm_a :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_ar :: Settings -> String

+ GHC.Driver.Session: sPgm_c :: Settings -> String

+ GHC.Driver.Session: sPgm_dll :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_i :: Settings -> String

+ GHC.Driver.Session: sPgm_l :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_lc :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_lcc :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_libtool :: Settings -> String

+ GHC.Driver.Session: sPgm_lo :: Settings -> (String, [Option])

+ GHC.Driver.Session: sPgm_ranlib :: Settings -> String

+ GHC.Driver.Session: sPgm_windres :: Settings -> String

+ GHC.Driver.Session: sProgramName :: Settings -> String

+ GHC.Driver.Session: sProjectVersion :: Settings -> String

+ GHC.Driver.Session: sTD_HDR_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: sTablesNextToCode :: Settings -> Bool

+ GHC.Driver.Session: sTargetPlatformString :: Settings -> String

+ GHC.Driver.Session: sTmpDir :: Settings -> String

+ GHC.Driver.Session: sToolDir :: Settings -> Maybe FilePath

+ GHC.Driver.Session: sTopDir :: Settings -> FilePath

+ GHC.Driver.Session: safeDirectImpsReq :: DynFlags -> Bool

+ GHC.Driver.Session: safeHaskellModeEnabled :: DynFlags -> Bool

+ GHC.Driver.Session: safeHaskellOn :: DynFlags -> Bool

+ GHC.Driver.Session: safeImplicitImpsReq :: DynFlags -> Bool

+ GHC.Driver.Session: safeImportsOn :: DynFlags -> Bool

+ GHC.Driver.Session: safeInferOn :: DynFlags -> Bool

+ GHC.Driver.Session: safeLanguageOn :: DynFlags -> Bool

+ GHC.Driver.Session: setFlagsFromEnvFile :: FilePath -> String -> DynP ()

+ GHC.Driver.Session: setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags

+ GHC.Driver.Session: setTmpDir :: FilePath -> DynFlags -> DynFlags

+ GHC.Driver.Session: setUnitId :: String -> DynFlags -> DynFlags

+ GHC.Driver.Session: setUnsafeGlobalDynFlags :: DynFlags -> IO ()

+ GHC.Driver.Session: settings :: DynFlags -> Settings

+ GHC.Driver.Session: showOpt :: Option -> String

+ GHC.Driver.Session: supportedLanguagesAndExtensions :: PlatformMini -> [String]

+ GHC.Driver.Session: tAG_BITS :: DynFlags -> Int

+ GHC.Driver.Session: tAG_MASK :: DynFlags -> Int

+ GHC.Driver.Session: tARGET_MAX_INT :: DynFlags -> Integer

+ GHC.Driver.Session: tARGET_MAX_WORD :: DynFlags -> Integer

+ GHC.Driver.Session: tARGET_MIN_INT :: DynFlags -> Integer

+ GHC.Driver.Session: tICKY_BIN_COUNT :: DynFlags -> Int

+ GHC.Driver.Session: tablesNextToCode :: DynFlags -> Bool

+ GHC.Driver.Session: targetRetainsAllBindings :: HscTarget -> Bool

+ GHC.Driver.Session: thisComponentId :: DynFlags -> ComponentId

+ GHC.Driver.Session: thisPackage :: DynFlags -> UnitId

+ GHC.Driver.Session: thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]

+ GHC.Driver.Session: tmpDir :: DynFlags -> String

+ GHC.Driver.Session: topDir :: DynFlags -> FilePath

+ GHC.Driver.Session: type FatalMessager = String -> IO ()

+ GHC.Driver.Session: type LogAction = DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()

+ GHC.Driver.Session: unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags

+ GHC.Driver.Session: unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

+ GHC.Driver.Session: unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

+ GHC.Driver.Session: unsafeGlobalDynFlags :: DynFlags

+ GHC.Driver.Session: updOptLevel :: Int -> DynFlags -> DynFlags

+ GHC.Driver.Session: updateWays :: DynFlags -> DynFlags

+ GHC.Driver.Session: versionedAppDir :: DynFlags -> MaybeT IO FilePath

+ GHC.Driver.Session: versionedFilePath :: DynFlags -> FilePath

+ GHC.Driver.Session: wORDS_BIGENDIAN :: DynFlags -> Bool

+ GHC.Driver.Session: wORD_SIZE :: DynFlags -> Int

+ GHC.Driver.Session: wORD_SIZE_IN_BITS :: DynFlags -> Int

+ GHC.Driver.Session: wWarningFlags :: [FlagSpec WarningFlag]

+ GHC.Driver.Session: warningGroups :: [(String, [WarningFlag])]

+ GHC.Driver.Session: warningHierarchies :: [[String]]

+ GHC.Driver.Session: wayGeneralFlags :: Platform -> Way -> [GeneralFlag]

+ GHC.Driver.Session: wayRTSOnly :: Way -> Bool

+ GHC.Driver.Session: wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]

+ GHC.Driver.Session: whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()

+ GHC.Driver.Session: whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()

+ GHC.Driver.Session: wopt :: WarningFlag -> DynFlags -> Bool

+ GHC.Driver.Session: wopt_fatal :: WarningFlag -> DynFlags -> Bool

+ GHC.Driver.Session: wopt_set :: DynFlags -> WarningFlag -> DynFlags

+ GHC.Driver.Session: wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags

+ GHC.Driver.Session: wopt_unset :: DynFlags -> WarningFlag -> DynFlags

+ GHC.Driver.Session: wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags

+ GHC.Driver.Session: wordAlignment :: DynFlags -> Alignment

+ GHC.Driver.Session: xFlags :: [FlagSpec Extension]

+ GHC.Driver.Session: xopt :: Extension -> DynFlags -> Bool

+ GHC.Driver.Session: xopt_set :: DynFlags -> Extension -> DynFlags

+ GHC.Driver.Session: xopt_set_unlessExplSpec :: Extension -> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags

+ GHC.Driver.Session: xopt_unset :: DynFlags -> Extension -> DynFlags

+ GHC.Driver.Types: ACoAxiom :: CoAxiom Branched -> TyThing

+ GHC.Driver.Types: AConLike :: ConLike -> TyThing

+ GHC.Driver.Types: ATyCon :: TyCon -> TyThing

+ GHC.Driver.Types: AnId :: Id -> TyThing

+ GHC.Driver.Types: BCOs :: CompiledByteCode -> [SptEntry] -> Unlinked

+ GHC.Driver.Types: CgGuts :: !Module -> [TyCon] -> CoreProgram -> !ForeignStubs -> ![(ForeignSrcLang, FilePath)] -> ![InstalledUnitId] -> !HpcInfo -> !Maybe ModBreaks -> [SptEntry] -> CgGuts

+ GHC.Driver.Types: CompleteMatch :: [Name] -> Name -> CompleteMatch

+ GHC.Driver.Types: DeprecatedTxt :: Located SourceText -> [Located StringLiteral] -> WarningTxt

+ GHC.Driver.Types: Deps :: [(ModuleName, IsBootInterface)] -> [(InstalledUnitId, Bool)] -> [Module] -> [Module] -> [ModuleName] -> Dependencies

+ GHC.Driver.Types: DotA :: FilePath -> Unlinked

+ GHC.Driver.Types: DotDLL :: FilePath -> Unlinked

+ GHC.Driver.Types: DotO :: FilePath -> Unlinked

+ GHC.Driver.Types: EPS :: !ModuleNameEnv (ModuleName, IsBootInterface) -> !PackageIfaceTable -> InstalledModuleEnv (UniqDSet ModuleName) -> !PackageTypeEnv -> !PackageInstEnv -> !PackageFamInstEnv -> !PackageRuleBase -> !PackageAnnEnv -> !PackageCompleteMatchMap -> !ModuleEnv FamInstEnv -> !EpsStats -> ExternalPackageState

+ GHC.Driver.Types: EpsStats :: !Int -> EpsStats

+ GHC.Driver.Types: FixItem :: OccName -> Fixity -> FixItem

+ GHC.Driver.Types: ForeignStubs :: SDoc -> SDoc -> ForeignStubs

+ GHC.Driver.Types: Found :: ModLocation -> Module -> FindResult

+ GHC.Driver.Types: FoundMultiple :: [(Module, ModuleOrigin)] -> FindResult

+ GHC.Driver.Types: HomeModInfo :: !ModIface -> !ModDetails -> !Maybe Linkable -> HomeModInfo

+ GHC.Driver.Types: HpcInfo :: Int -> Int -> HpcInfo

+ GHC.Driver.Types: HsBootFile :: HscSource

+ GHC.Driver.Types: HsParsedModule :: Located HsModule -> [FilePath] -> ApiAnns -> HsParsedModule

+ GHC.Driver.Types: HsSrcFile :: HscSource

+ GHC.Driver.Types: Hsc :: (HscEnv -> WarningMessages -> IO (a, WarningMessages)) -> Hsc a

+ GHC.Driver.Types: HscEnv :: DynFlags -> [Target] -> ModuleGraph -> InteractiveContext -> HomePackageTable -> {-# UNPACK #-} !IORef ExternalPackageState -> {-# UNPACK #-} !IORef NameCache -> {-# UNPACK #-} !IORef FinderCache -> Maybe (Module, IORef TypeEnv) -> Maybe Interp -> DynLinker -> HscEnv

+ GHC.Driver.Types: HscNotGeneratingCode :: ModIface -> ModDetails -> HscStatus

+ GHC.Driver.Types: HscRecomp :: CgGuts -> !ModLocation -> !ModDetails -> !PartialModIface -> !Maybe Fingerprint -> !DynFlags -> HscStatus

+ GHC.Driver.Types: HscUpToDate :: ModIface -> ModDetails -> HscStatus

+ GHC.Driver.Types: HscUpdateBoot :: ModIface -> ModDetails -> HscStatus

+ GHC.Driver.Types: HscUpdateSig :: ModIface -> ModDetails -> HscStatus

+ GHC.Driver.Types: HsigFile :: HscSource

+ GHC.Driver.Types: IIDecl :: ImportDecl GhcPs -> InteractiveImport

+ GHC.Driver.Types: IIModule :: ModuleName -> InteractiveImport

+ GHC.Driver.Types: ImportedBySystem :: ImportedBy

+ GHC.Driver.Types: ImportedByUser :: ImportedModsVal -> ImportedBy

+ GHC.Driver.Types: ImportedModsVal :: ModuleName -> SrcSpan -> IsSafeImport -> Bool -> !GlobalRdrEnv -> Bool -> ImportedModsVal

+ GHC.Driver.Types: InstalledFound :: ModLocation -> InstalledModule -> InstalledFindResult

+ GHC.Driver.Types: InstalledNoPackage :: InstalledUnitId -> InstalledFindResult

+ GHC.Driver.Types: InstalledNotFound :: [FilePath] -> Maybe InstalledUnitId -> InstalledFindResult

+ GHC.Driver.Types: InteractiveContext :: DynFlags -> Int -> [InteractiveImport] -> [TyThing] -> GlobalRdrEnv -> ([ClsInst], [FamInst]) -> FixityEnv -> Maybe [Type] -> [Resume] -> Name -> Name -> Maybe FilePath -> InteractiveContext

+ GHC.Driver.Types: LM :: UTCTime -> Module -> [Unlinked] -> Linkable

+ GHC.Driver.Types: LangAsm :: ForeignSrcLang

+ GHC.Driver.Types: LangC :: ForeignSrcLang

+ GHC.Driver.Types: LangCxx :: ForeignSrcLang

+ GHC.Driver.Types: LangObjc :: ForeignSrcLang

+ GHC.Driver.Types: LangObjcxx :: ForeignSrcLang

+ GHC.Driver.Types: MetaAW :: (Serialized -> MetaResult) -> MetaRequest

+ GHC.Driver.Types: MetaD :: ([LHsDecl GhcPs] -> MetaResult) -> MetaRequest

+ GHC.Driver.Types: MetaE :: (LHsExpr GhcPs -> MetaResult) -> MetaRequest

+ GHC.Driver.Types: MetaP :: (LPat GhcPs -> MetaResult) -> MetaRequest

+ GHC.Driver.Types: MetaT :: (LHsType GhcPs -> MetaResult) -> MetaRequest

+ GHC.Driver.Types: ModBreaks :: ForeignRef BreakArray -> !Array BreakIndex SrcSpan -> !Array BreakIndex [OccName] -> !Array BreakIndex [String] -> !Array BreakIndex (RemotePtr CostCentre) -> IntMap CgBreakInfo -> ModBreaks

+ GHC.Driver.Types: ModDetails :: [AvailInfo] -> !TypeEnv -> ![ClsInst] -> ![FamInst] -> ![CoreRule] -> ![Annotation] -> [CompleteMatch] -> ModDetails

+ GHC.Driver.Types: ModGuts :: !Module -> HscSource -> SrcSpan -> ![AvailInfo] -> !Dependencies -> ![Usage] -> !Bool -> !GlobalRdrEnv -> !FixityEnv -> ![TyCon] -> ![ClsInst] -> ![FamInst] -> ![PatSyn] -> ![CoreRule] -> !CoreProgram -> !ForeignStubs -> ![(ForeignSrcLang, FilePath)] -> !Warnings -> [Annotation] -> [CompleteMatch] -> !HpcInfo -> !Maybe ModBreaks -> InstEnv -> FamInstEnv -> SafeHaskellMode -> Bool -> !Maybe HsDocString -> !DeclDocMap -> !ArgDocMap -> ModGuts

+ GHC.Driver.Types: ModIface :: !Module -> !Maybe Module -> !HscSource -> Dependencies -> [Usage] -> ![IfaceExport] -> !Bool -> [(OccName, Fixity)] -> Warnings -> [IfaceAnnotation] -> [IfaceDeclExts phase] -> !Maybe GlobalRdrEnv -> [IfaceClsInst] -> [IfaceFamInst] -> [IfaceRule] -> !AnyHpcUsage -> !IfaceTrustInfo -> !Bool -> [IfaceCompleteMatch] -> Maybe HsDocString -> DeclDocMap -> ArgDocMap -> !IfaceBackendExts phase -> ModIface_

+ GHC.Driver.Types: ModIfaceBackend :: !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !Fingerprint -> !WhetherHasOrphans -> !WhetherHasFamInst -> !Fingerprint -> !Fingerprint -> !OccName -> Maybe WarningTxt -> !OccName -> Maybe Fixity -> !OccName -> Maybe (OccName, Fingerprint) -> ModIfaceBackend

+ GHC.Driver.Types: ModSummary :: Module -> HscSource -> ModLocation -> UTCTime -> Maybe UTCTime -> Maybe UTCTime -> Maybe UTCTime -> [(Maybe FastString, Located ModuleName)] -> [(Maybe FastString, Located ModuleName)] -> Maybe HsParsedModule -> FilePath -> DynFlags -> Maybe StringBuffer -> ModSummary

+ GHC.Driver.Types: NoHpcInfo :: AnyHpcUsage -> HpcInfo

+ GHC.Driver.Types: NoPackage :: UnitId -> FindResult

+ GHC.Driver.Types: NoStubs :: ForeignStubs

+ GHC.Driver.Types: NoWarnings :: Warnings

+ GHC.Driver.Types: NotFound :: [FilePath] -> Maybe UnitId -> [UnitId] -> [UnitId] -> [(UnitId, UnusablePackageReason)] -> [ModuleSuggestion] -> FindResult

+ GHC.Driver.Types: RawObject :: ForeignSrcLang

+ GHC.Driver.Types: SourceModified :: SourceModified

+ GHC.Driver.Types: SourceUnmodified :: SourceModified

+ GHC.Driver.Types: SourceUnmodifiedAndStable :: SourceModified

+ GHC.Driver.Types: SptEntry :: Id -> Fingerprint -> SptEntry

+ GHC.Driver.Types: Target :: TargetId -> Bool -> Maybe (InputFileBuffer, UTCTime) -> Target

+ GHC.Driver.Types: TargetFile :: FilePath -> Maybe Phase -> TargetId

+ GHC.Driver.Types: TargetModule :: ModuleName -> TargetId

+ GHC.Driver.Types: UsageFile :: FilePath -> Fingerprint -> Usage

+ GHC.Driver.Types: UsageHomeModule :: ModuleName -> Fingerprint -> [(OccName, Fingerprint)] -> Maybe Fingerprint -> IsSafeImport -> Usage

+ GHC.Driver.Types: UsageMergedRequirement :: Module -> Fingerprint -> Usage

+ GHC.Driver.Types: UsagePackageModule :: Module -> Fingerprint -> IsSafeImport -> Usage

+ GHC.Driver.Types: WarnAll :: WarningTxt -> Warnings

+ GHC.Driver.Types: WarnSome :: [(OccName, WarningTxt)] -> Warnings

+ GHC.Driver.Types: WarningTxt :: Located SourceText -> [Located StringLiteral] -> WarningTxt

+ GHC.Driver.Types: [cg_binds] :: CgGuts -> CoreProgram

+ GHC.Driver.Types: [cg_dep_pkgs] :: CgGuts -> ![InstalledUnitId]

+ GHC.Driver.Types: [cg_foreign] :: CgGuts -> !ForeignStubs

+ GHC.Driver.Types: [cg_foreign_files] :: CgGuts -> ![(ForeignSrcLang, FilePath)]

+ GHC.Driver.Types: [cg_hpc_info] :: CgGuts -> !HpcInfo

+ GHC.Driver.Types: [cg_modBreaks] :: CgGuts -> !Maybe ModBreaks

+ GHC.Driver.Types: [cg_module] :: CgGuts -> !Module

+ GHC.Driver.Types: [cg_spt_entries] :: CgGuts -> [SptEntry]

+ GHC.Driver.Types: [cg_tycons] :: CgGuts -> [TyCon]

+ GHC.Driver.Types: [completeMatchConLikes] :: CompleteMatch -> [Name]

+ GHC.Driver.Types: [completeMatchTyCon] :: CompleteMatch -> Name

+ GHC.Driver.Types: [dep_finsts] :: Dependencies -> [Module]

+ GHC.Driver.Types: [dep_mods] :: Dependencies -> [(ModuleName, IsBootInterface)]

+ GHC.Driver.Types: [dep_orphs] :: Dependencies -> [Module]

+ GHC.Driver.Types: [dep_pkgs] :: Dependencies -> [(InstalledUnitId, Bool)]

+ GHC.Driver.Types: [dep_plgins] :: Dependencies -> [ModuleName]

+ GHC.Driver.Types: [eps_PIT] :: ExternalPackageState -> !PackageIfaceTable

+ GHC.Driver.Types: [eps_PTE] :: ExternalPackageState -> !PackageTypeEnv

+ GHC.Driver.Types: [eps_ann_env] :: ExternalPackageState -> !PackageAnnEnv

+ GHC.Driver.Types: [eps_complete_matches] :: ExternalPackageState -> !PackageCompleteMatchMap

+ GHC.Driver.Types: [eps_fam_inst_env] :: ExternalPackageState -> !PackageFamInstEnv

+ GHC.Driver.Types: [eps_free_holes] :: ExternalPackageState -> InstalledModuleEnv (UniqDSet ModuleName)

+ GHC.Driver.Types: [eps_inst_env] :: ExternalPackageState -> !PackageInstEnv

+ GHC.Driver.Types: [eps_is_boot] :: ExternalPackageState -> !ModuleNameEnv (ModuleName, IsBootInterface)

+ GHC.Driver.Types: [eps_mod_fam_inst_env] :: ExternalPackageState -> !ModuleEnv FamInstEnv

+ GHC.Driver.Types: [eps_rule_base] :: ExternalPackageState -> !PackageRuleBase

+ GHC.Driver.Types: [eps_stats] :: ExternalPackageState -> !EpsStats

+ GHC.Driver.Types: [fr_mods_hidden] :: FindResult -> [UnitId]

+ GHC.Driver.Types: [fr_paths] :: FindResult -> [FilePath]

+ GHC.Driver.Types: [fr_pkg] :: FindResult -> Maybe UnitId

+ GHC.Driver.Types: [fr_pkgs_hidden] :: FindResult -> [UnitId]

+ GHC.Driver.Types: [fr_suggestions] :: FindResult -> [ModuleSuggestion]

+ GHC.Driver.Types: [fr_unusables] :: FindResult -> [(UnitId, UnusablePackageReason)]

+ GHC.Driver.Types: [hm_details] :: HomeModInfo -> !ModDetails

+ GHC.Driver.Types: [hm_iface] :: HomeModInfo -> !ModIface

+ GHC.Driver.Types: [hm_linkable] :: HomeModInfo -> !Maybe Linkable

+ GHC.Driver.Types: [hpcInfoHash] :: HpcInfo -> Int

+ GHC.Driver.Types: [hpcInfoTickCount] :: HpcInfo -> Int

+ GHC.Driver.Types: [hpcUsed] :: HpcInfo -> AnyHpcUsage

+ GHC.Driver.Types: [hpm_annotations] :: HsParsedModule -> ApiAnns

+ GHC.Driver.Types: [hpm_module] :: HsParsedModule -> Located HsModule

+ GHC.Driver.Types: [hpm_src_files] :: HsParsedModule -> [FilePath]

+ GHC.Driver.Types: [hsc_EPS] :: HscEnv -> {-# UNPACK #-} !IORef ExternalPackageState

+ GHC.Driver.Types: [hsc_FC] :: HscEnv -> {-# UNPACK #-} !IORef FinderCache

+ GHC.Driver.Types: [hsc_HPT] :: HscEnv -> HomePackageTable

+ GHC.Driver.Types: [hsc_IC] :: HscEnv -> InteractiveContext

+ GHC.Driver.Types: [hsc_NC] :: HscEnv -> {-# UNPACK #-} !IORef NameCache

+ GHC.Driver.Types: [hsc_dflags] :: HscEnv -> DynFlags

+ GHC.Driver.Types: [hsc_dynLinker] :: HscEnv -> DynLinker

+ GHC.Driver.Types: [hsc_interp] :: HscEnv -> Maybe Interp

+ GHC.Driver.Types: [hsc_mod_graph] :: HscEnv -> ModuleGraph

+ GHC.Driver.Types: [hsc_targets] :: HscEnv -> [Target]

+ GHC.Driver.Types: [hsc_type_env_var] :: HscEnv -> Maybe (Module, IORef TypeEnv)

+ GHC.Driver.Types: [hscs_guts] :: HscStatus -> CgGuts

+ GHC.Driver.Types: [hscs_iface_dflags] :: HscStatus -> !DynFlags

+ GHC.Driver.Types: [hscs_mod_details] :: HscStatus -> !ModDetails

+ GHC.Driver.Types: [hscs_mod_location] :: HscStatus -> !ModLocation

+ GHC.Driver.Types: [hscs_old_iface_hash] :: HscStatus -> !Maybe Fingerprint

+ GHC.Driver.Types: [hscs_partial_iface] :: HscStatus -> !PartialModIface

+ GHC.Driver.Types: [ic_cwd] :: InteractiveContext -> Maybe FilePath

+ GHC.Driver.Types: [ic_default] :: InteractiveContext -> Maybe [Type]

+ GHC.Driver.Types: [ic_dflags] :: InteractiveContext -> DynFlags

+ GHC.Driver.Types: [ic_fix_env] :: InteractiveContext -> FixityEnv

+ GHC.Driver.Types: [ic_imports] :: InteractiveContext -> [InteractiveImport]

+ GHC.Driver.Types: [ic_instances] :: InteractiveContext -> ([ClsInst], [FamInst])

+ GHC.Driver.Types: [ic_int_print] :: InteractiveContext -> Name

+ GHC.Driver.Types: [ic_mod_index] :: InteractiveContext -> Int

+ GHC.Driver.Types: [ic_monad] :: InteractiveContext -> Name

+ GHC.Driver.Types: [ic_resume] :: InteractiveContext -> [Resume]

+ GHC.Driver.Types: [ic_rn_gbl_env] :: InteractiveContext -> GlobalRdrEnv

+ GHC.Driver.Types: [ic_tythings] :: InteractiveContext -> [TyThing]

+ GHC.Driver.Types: [imv_all_exports] :: ImportedModsVal -> !GlobalRdrEnv

+ GHC.Driver.Types: [imv_is_hiding] :: ImportedModsVal -> Bool

+ GHC.Driver.Types: [imv_is_safe] :: ImportedModsVal -> IsSafeImport

+ GHC.Driver.Types: [imv_name] :: ImportedModsVal -> ModuleName

+ GHC.Driver.Types: [imv_qualified] :: ImportedModsVal -> Bool

+ GHC.Driver.Types: [imv_span] :: ImportedModsVal -> SrcSpan

+ GHC.Driver.Types: [linkableModule] :: Linkable -> Module

+ GHC.Driver.Types: [linkableTime] :: Linkable -> UTCTime

+ GHC.Driver.Types: [linkableUnlinked] :: Linkable -> [Unlinked]

+ GHC.Driver.Types: [md_anns] :: ModDetails -> ![Annotation]

+ GHC.Driver.Types: [md_complete_sigs] :: ModDetails -> [CompleteMatch]

+ GHC.Driver.Types: [md_exports] :: ModDetails -> [AvailInfo]

+ GHC.Driver.Types: [md_fam_insts] :: ModDetails -> ![FamInst]

+ GHC.Driver.Types: [md_insts] :: ModDetails -> ![ClsInst]

+ GHC.Driver.Types: [md_rules] :: ModDetails -> ![CoreRule]

+ GHC.Driver.Types: [md_types] :: ModDetails -> !TypeEnv

+ GHC.Driver.Types: [mg_anns] :: ModGuts -> [Annotation]

+ GHC.Driver.Types: [mg_arg_docs] :: ModGuts -> !ArgDocMap

+ GHC.Driver.Types: [mg_binds] :: ModGuts -> !CoreProgram

+ GHC.Driver.Types: [mg_complete_sigs] :: ModGuts -> [CompleteMatch]

+ GHC.Driver.Types: [mg_decl_docs] :: ModGuts -> !DeclDocMap

+ GHC.Driver.Types: [mg_deps] :: ModGuts -> !Dependencies

+ GHC.Driver.Types: [mg_doc_hdr] :: ModGuts -> !Maybe HsDocString

+ GHC.Driver.Types: [mg_exports] :: ModGuts -> ![AvailInfo]

+ GHC.Driver.Types: [mg_fam_inst_env] :: ModGuts -> FamInstEnv

+ GHC.Driver.Types: [mg_fam_insts] :: ModGuts -> ![FamInst]

+ GHC.Driver.Types: [mg_fix_env] :: ModGuts -> !FixityEnv

+ GHC.Driver.Types: [mg_foreign] :: ModGuts -> !ForeignStubs

+ GHC.Driver.Types: [mg_foreign_files] :: ModGuts -> ![(ForeignSrcLang, FilePath)]

+ GHC.Driver.Types: [mg_hpc_info] :: ModGuts -> !HpcInfo

+ GHC.Driver.Types: [mg_hsc_src] :: ModGuts -> HscSource

+ GHC.Driver.Types: [mg_inst_env] :: ModGuts -> InstEnv

+ GHC.Driver.Types: [mg_insts] :: ModGuts -> ![ClsInst]

+ GHC.Driver.Types: [mg_loc] :: ModGuts -> SrcSpan

+ GHC.Driver.Types: [mg_modBreaks] :: ModGuts -> !Maybe ModBreaks

+ GHC.Driver.Types: [mg_module] :: ModGuts -> !Module

+ GHC.Driver.Types: [mg_patsyns] :: ModGuts -> ![PatSyn]

+ GHC.Driver.Types: [mg_rdr_env] :: ModGuts -> !GlobalRdrEnv

+ GHC.Driver.Types: [mg_rules] :: ModGuts -> ![CoreRule]

+ GHC.Driver.Types: [mg_safe_haskell] :: ModGuts -> SafeHaskellMode

+ GHC.Driver.Types: [mg_tcs] :: ModGuts -> ![TyCon]

+ GHC.Driver.Types: [mg_trust_pkg] :: ModGuts -> Bool

+ GHC.Driver.Types: [mg_usages] :: ModGuts -> ![Usage]

+ GHC.Driver.Types: [mg_used_th] :: ModGuts -> !Bool

+ GHC.Driver.Types: [mg_warns] :: ModGuts -> !Warnings

+ GHC.Driver.Types: [mi_anns] :: ModIface_ -> [IfaceAnnotation]

+ GHC.Driver.Types: [mi_arg_docs] :: ModIface_ -> ArgDocMap

+ GHC.Driver.Types: [mi_complete_sigs] :: ModIface_ -> [IfaceCompleteMatch]

+ GHC.Driver.Types: [mi_decl_docs] :: ModIface_ -> DeclDocMap

+ GHC.Driver.Types: [mi_decls] :: ModIface_ -> [IfaceDeclExts phase]

+ GHC.Driver.Types: [mi_deps] :: ModIface_ -> Dependencies

+ GHC.Driver.Types: [mi_doc_hdr] :: ModIface_ -> Maybe HsDocString

+ GHC.Driver.Types: [mi_exp_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_exports] :: ModIface_ -> ![IfaceExport]

+ GHC.Driver.Types: [mi_fam_insts] :: ModIface_ -> [IfaceFamInst]

+ GHC.Driver.Types: [mi_final_exts] :: ModIface_ -> !IfaceBackendExts phase

+ GHC.Driver.Types: [mi_finsts] :: ModIfaceBackend -> !WhetherHasFamInst

+ GHC.Driver.Types: [mi_fix_fn] :: ModIfaceBackend -> !OccName -> Maybe Fixity

+ GHC.Driver.Types: [mi_fixities] :: ModIface_ -> [(OccName, Fixity)]

+ GHC.Driver.Types: [mi_flag_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_globals] :: ModIface_ -> !Maybe GlobalRdrEnv

+ GHC.Driver.Types: [mi_hash_fn] :: ModIfaceBackend -> !OccName -> Maybe (OccName, Fingerprint)

+ GHC.Driver.Types: [mi_hpc] :: ModIface_ -> !AnyHpcUsage

+ GHC.Driver.Types: [mi_hpc_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_hsc_src] :: ModIface_ -> !HscSource

+ GHC.Driver.Types: [mi_iface_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_insts] :: ModIface_ -> [IfaceClsInst]

+ GHC.Driver.Types: [mi_mod_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_module] :: ModIface_ -> !Module

+ GHC.Driver.Types: [mi_opt_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_orphan] :: ModIfaceBackend -> !WhetherHasOrphans

+ GHC.Driver.Types: [mi_orphan_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_plugin_hash] :: ModIfaceBackend -> !Fingerprint

+ GHC.Driver.Types: [mi_rules] :: ModIface_ -> [IfaceRule]

+ GHC.Driver.Types: [mi_sig_of] :: ModIface_ -> !Maybe Module

+ GHC.Driver.Types: [mi_trust] :: ModIface_ -> !IfaceTrustInfo

+ GHC.Driver.Types: [mi_trust_pkg] :: ModIface_ -> !Bool

+ GHC.Driver.Types: [mi_usages] :: ModIface_ -> [Usage]

+ GHC.Driver.Types: [mi_used_th] :: ModIface_ -> !Bool

+ GHC.Driver.Types: [mi_warn_fn] :: ModIfaceBackend -> !OccName -> Maybe WarningTxt

+ GHC.Driver.Types: [mi_warns] :: ModIface_ -> Warnings

+ GHC.Driver.Types: [modBreaks_breakInfo] :: ModBreaks -> IntMap CgBreakInfo

+ GHC.Driver.Types: [modBreaks_ccs] :: ModBreaks -> !Array BreakIndex (RemotePtr CostCentre)

+ GHC.Driver.Types: [modBreaks_decls] :: ModBreaks -> !Array BreakIndex [String]

+ GHC.Driver.Types: [modBreaks_flags] :: ModBreaks -> ForeignRef BreakArray

+ GHC.Driver.Types: [modBreaks_locs] :: ModBreaks -> !Array BreakIndex SrcSpan

+ GHC.Driver.Types: [modBreaks_vars] :: ModBreaks -> !Array BreakIndex [OccName]

+ GHC.Driver.Types: [ms_hie_date] :: ModSummary -> Maybe UTCTime

+ GHC.Driver.Types: [ms_hs_date] :: ModSummary -> UTCTime

+ GHC.Driver.Types: [ms_hsc_src] :: ModSummary -> HscSource

+ GHC.Driver.Types: [ms_hspp_buf] :: ModSummary -> Maybe StringBuffer

+ GHC.Driver.Types: [ms_hspp_file] :: ModSummary -> FilePath

+ GHC.Driver.Types: [ms_hspp_opts] :: ModSummary -> DynFlags

+ GHC.Driver.Types: [ms_iface_date] :: ModSummary -> Maybe UTCTime

+ GHC.Driver.Types: [ms_location] :: ModSummary -> ModLocation

+ GHC.Driver.Types: [ms_mod] :: ModSummary -> Module

+ GHC.Driver.Types: [ms_obj_date] :: ModSummary -> Maybe UTCTime

+ GHC.Driver.Types: [ms_parsed_mod] :: ModSummary -> Maybe HsParsedModule

+ GHC.Driver.Types: [ms_srcimps] :: ModSummary -> [(Maybe FastString, Located ModuleName)]

+ GHC.Driver.Types: [ms_textual_imps] :: ModSummary -> [(Maybe FastString, Located ModuleName)]

+ GHC.Driver.Types: [n_ifaces_in, n_decls_in, n_decls_out, n_rules_in, n_rules_out, n_insts_in, n_insts_out] :: EpsStats -> !Int

+ GHC.Driver.Types: [targetAllowObjCode] :: Target -> Bool

+ GHC.Driver.Types: [targetContents] :: Target -> Maybe (InputFileBuffer, UTCTime)

+ GHC.Driver.Types: [targetId] :: Target -> TargetId

+ GHC.Driver.Types: [usg_entities] :: Usage -> [(OccName, Fingerprint)]

+ GHC.Driver.Types: [usg_exports] :: Usage -> Maybe Fingerprint

+ GHC.Driver.Types: [usg_file_hash] :: Usage -> Fingerprint

+ GHC.Driver.Types: [usg_file_path] :: Usage -> FilePath

+ GHC.Driver.Types: [usg_mod] :: Usage -> Module

+ GHC.Driver.Types: [usg_mod_hash] :: Usage -> Fingerprint

+ GHC.Driver.Types: [usg_mod_name] :: Usage -> ModuleName

+ GHC.Driver.Types: [usg_safe] :: Usage -> IsSafeImport

+ GHC.Driver.Types: addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats

+ GHC.Driver.Types: addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable

+ GHC.Driver.Types: addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable

+ GHC.Driver.Types: allHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> Bool

+ GHC.Driver.Types: appendStubC :: ForeignStubs -> SDoc -> ForeignStubs

+ GHC.Driver.Types: byteCodeOfObject :: Unlinked -> CompiledByteCode

+ GHC.Driver.Types: class Monad m => MonadThings m

+ GHC.Driver.Types: data CgGuts

+ GHC.Driver.Types: data CompiledByteCode

+ GHC.Driver.Types: data CompleteMatch

+ GHC.Driver.Types: data Dependencies

+ GHC.Driver.Types: data EpsStats

+ GHC.Driver.Types: data ExternalPackageState

+ GHC.Driver.Types: data FindResult

+ GHC.Driver.Types: data FixItem

+ GHC.Driver.Types: data ForeignSrcLang

+ GHC.Driver.Types: data ForeignStubs

+ GHC.Driver.Types: data GhcApiError

+ GHC.Driver.Types: data HomeModInfo

+ GHC.Driver.Types: data HpcInfo

+ GHC.Driver.Types: data HsParsedModule

+ GHC.Driver.Types: data HscEnv

+ GHC.Driver.Types: data HscSource

+ GHC.Driver.Types: data HscStatus

+ GHC.Driver.Types: data IfaceTrustInfo

+ GHC.Driver.Types: data ImportedBy

+ GHC.Driver.Types: data ImportedModsVal

+ GHC.Driver.Types: data InstalledFindResult

+ GHC.Driver.Types: data InteractiveContext

+ GHC.Driver.Types: data InteractiveImport

+ GHC.Driver.Types: data Linkable

+ GHC.Driver.Types: data MetaRequest

+ GHC.Driver.Types: data MetaResult

+ GHC.Driver.Types: data ModBreaks

+ GHC.Driver.Types: data ModDetails

+ GHC.Driver.Types: data ModGuts

+ GHC.Driver.Types: data ModIfaceBackend

+ GHC.Driver.Types: data ModIface_ (phase :: ModIfacePhase)

+ GHC.Driver.Types: data ModSummary

+ GHC.Driver.Types: data ModuleGraph

+ GHC.Driver.Types: data SourceError

+ GHC.Driver.Types: data SourceModified

+ GHC.Driver.Types: data SptEntry

+ GHC.Driver.Types: data Target

+ GHC.Driver.Types: data TargetId

+ GHC.Driver.Types: data TyThing

+ GHC.Driver.Types: data Unlinked

+ GHC.Driver.Types: data Usage

+ GHC.Driver.Types: data WarningTxt

+ GHC.Driver.Types: data Warnings

+ GHC.Driver.Types: delFromHpt :: HomePackageTable -> ModuleName -> HomePackageTable

+ GHC.Driver.Types: eltsHpt :: HomePackageTable -> [HomeModInfo]

+ GHC.Driver.Types: emptyFixityEnv :: FixityEnv

+ GHC.Driver.Types: emptyFullModIface :: Module -> ModIface

+ GHC.Driver.Types: emptyHomePackageTable :: HomePackageTable

+ GHC.Driver.Types: emptyHpcInfo :: AnyHpcUsage -> HpcInfo

+ GHC.Driver.Types: emptyIfaceWarnCache :: OccName -> Maybe WarningTxt

+ GHC.Driver.Types: emptyInteractiveContext :: DynFlags -> InteractiveContext

+ GHC.Driver.Types: emptyMG :: ModuleGraph

+ GHC.Driver.Types: emptyModBreaks :: ModBreaks

+ GHC.Driver.Types: emptyModDetails :: ModDetails

+ GHC.Driver.Types: emptyPackageIfaceTable :: PackageIfaceTable

+ GHC.Driver.Types: emptyPartialModIface :: Module -> PartialModIface

+ GHC.Driver.Types: emptyTypeEnv :: TypeEnv

+ GHC.Driver.Types: extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap

+ GHC.Driver.Types: extendInteractiveContext :: InteractiveContext -> [TyThing] -> [ClsInst] -> [FamInst] -> Maybe [Type] -> FixityEnv -> InteractiveContext

+ GHC.Driver.Types: extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext

+ GHC.Driver.Types: extendMG :: ModuleGraph -> ModSummary -> ModuleGraph

+ GHC.Driver.Types: extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv

+ GHC.Driver.Types: extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv

+ GHC.Driver.Types: extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv

+ GHC.Driver.Types: filterHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> HomePackageTable

+ GHC.Driver.Types: getSafeMode :: IfaceTrustInfo -> SafeHaskellMode

+ GHC.Driver.Types: handleFlagWarnings :: DynFlags -> [Warn] -> IO ()

+ GHC.Driver.Types: handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a

+ GHC.Driver.Types: home_imps :: [(Maybe FastString, Located ModuleName)] -> [Located ModuleName]

+ GHC.Driver.Types: hptCompleteSigs :: HscEnv -> [CompleteMatch]

+ GHC.Driver.Types: hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])

+ GHC.Driver.Types: hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]

+ GHC.Driver.Types: hscEPS :: HscEnv -> IO ExternalPackageState

+ GHC.Driver.Types: hscSourceString :: HscSource -> String

+ GHC.Driver.Types: icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv

+ GHC.Driver.Types: icInScopeTTs :: InteractiveContext -> [TyThing]

+ GHC.Driver.Types: icInteractiveModule :: InteractiveContext -> Module

+ GHC.Driver.Types: icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified

+ GHC.Driver.Types: implicitClassThings :: Class -> [TyThing]

+ GHC.Driver.Types: implicitTyConThings :: TyCon -> [TyThing]

+ GHC.Driver.Types: implicitTyThings :: TyThing -> [TyThing]

+ GHC.Driver.Types: importedByUser :: [ImportedBy] -> [ImportedModsVal]

+ GHC.Driver.Types: instance (Control.DeepSeq.NFData (GHC.Driver.Types.IfaceBackendExts phase), Control.DeepSeq.NFData (GHC.Driver.Types.IfaceDeclExts phase)) => Control.DeepSeq.NFData (GHC.Driver.Types.ModIface_ phase)

+ GHC.Driver.Types: instance Binary.Binary GHC.Driver.Types.Dependencies

+ GHC.Driver.Types: instance Binary.Binary GHC.Driver.Types.IfaceTrustInfo

+ GHC.Driver.Types: instance Binary.Binary GHC.Driver.Types.ModIface

+ GHC.Driver.Types: instance Binary.Binary GHC.Driver.Types.Usage

+ GHC.Driver.Types: instance Binary.Binary GHC.Driver.Types.Warnings

+ GHC.Driver.Types: instance Control.Monad.IO.Class.MonadIO GHC.Driver.Types.Hsc

+ GHC.Driver.Types: instance GHC.Base.Applicative GHC.Driver.Types.Hsc

+ GHC.Driver.Types: instance GHC.Base.Functor GHC.Driver.Types.Hsc

+ GHC.Driver.Types: instance GHC.Base.Monad GHC.Driver.Types.Hsc

+ GHC.Driver.Types: instance GHC.Classes.Eq GHC.Driver.Types.Dependencies

+ GHC.Driver.Types: instance GHC.Classes.Eq GHC.Driver.Types.TargetId

+ GHC.Driver.Types: instance GHC.Classes.Eq GHC.Driver.Types.Usage

+ GHC.Driver.Types: instance GHC.Classes.Eq GHC.Driver.Types.Warnings

+ GHC.Driver.Types: instance GHC.Driver.Session.HasDynFlags GHC.Driver.Types.Hsc

+ GHC.Driver.Types: instance GHC.Driver.Types.MonadThings m => GHC.Driver.Types.MonadThings (Control.Monad.Trans.Reader.ReaderT s m)

+ GHC.Driver.Types: instance GHC.Exception.Type.Exception GHC.Driver.Types.GhcApiError

+ GHC.Driver.Types: instance GHC.Exception.Type.Exception GHC.Driver.Types.SourceError

+ GHC.Driver.Types: instance GHC.Show.Show GHC.Driver.Types.GhcApiError

+ GHC.Driver.Types: instance GHC.Show.Show GHC.Driver.Types.SourceError

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.CompleteMatch

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.FixItem

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.IfaceTrustInfo

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.InteractiveImport

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.ModSummary

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.Target

+ GHC.Driver.Types: instance Outputable.Outputable GHC.Driver.Types.TargetId

+ GHC.Driver.Types: isBootSummary :: ModSummary -> Bool

+ GHC.Driver.Types: isHpcUsed :: HpcInfo -> AnyHpcUsage

+ GHC.Driver.Types: isHsBootOrSig :: HscSource -> Bool

+ GHC.Driver.Types: isHsigFile :: HscSource -> Bool

+ GHC.Driver.Types: isImplicitTyThing :: TyThing -> Bool

+ GHC.Driver.Types: isInterpretable :: Unlinked -> Bool

+ GHC.Driver.Types: isObject :: Unlinked -> Bool

+ GHC.Driver.Types: isObjectLinkable :: Linkable -> Bool

+ GHC.Driver.Types: isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool

+ GHC.Driver.Types: linkableObjs :: Linkable -> [FilePath]

+ GHC.Driver.Types: listToHpt :: [(ModuleName, HomeModInfo)] -> HomePackageTable

+ GHC.Driver.Types: lookupDataCon :: MonadThings m => Name -> m DataCon

+ GHC.Driver.Types: lookupFixity :: FixityEnv -> Name -> Fixity

+ GHC.Driver.Types: lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo

+ GHC.Driver.Types: lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo

+ GHC.Driver.Types: lookupHptDirectly :: HomePackageTable -> Unique -> Maybe HomeModInfo

+ GHC.Driver.Types: lookupId :: MonadThings m => Name -> m Id

+ GHC.Driver.Types: lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface

+ GHC.Driver.Types: lookupThing :: MonadThings m => Name -> m TyThing

+ GHC.Driver.Types: lookupTyCon :: MonadThings m => Name -> m TyCon

+ GHC.Driver.Types: lookupType :: DynFlags -> HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing

+ GHC.Driver.Types: lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing

+ GHC.Driver.Types: lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)

+ GHC.Driver.Types: mapHpt :: (HomeModInfo -> HomeModInfo) -> HomePackageTable -> HomePackageTable

+ GHC.Driver.Types: mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph

+ GHC.Driver.Types: metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized

+ GHC.Driver.Types: metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]

+ GHC.Driver.Types: metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)

+ GHC.Driver.Types: metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)

+ GHC.Driver.Types: metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)

+ GHC.Driver.Types: mgBootModules :: ModuleGraph -> ModuleSet

+ GHC.Driver.Types: mgElemModule :: ModuleGraph -> Module -> Bool

+ GHC.Driver.Types: mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary

+ GHC.Driver.Types: mgModSummaries :: ModuleGraph -> [ModSummary]

+ GHC.Driver.Types: mi_boot :: ModIface -> Bool

+ GHC.Driver.Types: mi_fix :: ModIface -> OccName -> Fixity

+ GHC.Driver.Types: mi_free_holes :: ModIface -> UniqDSet ModuleName

+ GHC.Driver.Types: mi_semantic_module :: ModIface_ a -> Module

+ GHC.Driver.Types: mkApiErr :: DynFlags -> SDoc -> GhcApiError

+ GHC.Driver.Types: mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap

+ GHC.Driver.Types: mkHsSOName :: Platform -> FilePath -> FilePath

+ GHC.Driver.Types: mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity

+ GHC.Driver.Types: mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> OccName -> Maybe (OccName, Fingerprint)

+ GHC.Driver.Types: mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt

+ GHC.Driver.Types: mkInteractiveHscEnv :: HscEnv -> HscEnv

+ GHC.Driver.Types: mkModuleGraph :: [ModSummary] -> ModuleGraph

+ GHC.Driver.Types: mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified

+ GHC.Driver.Types: mkQualModule :: DynFlags -> QueryQualifyModule

+ GHC.Driver.Types: mkQualPackage :: DynFlags -> QueryQualifyPackage

+ GHC.Driver.Types: mkSOName :: Platform -> FilePath -> FilePath

+ GHC.Driver.Types: mkSrcErr :: ErrorMessages -> SourceError

+ GHC.Driver.Types: mkTypeEnv :: [TyThing] -> TypeEnv

+ GHC.Driver.Types: mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv

+ GHC.Driver.Types: msHiFilePath :: ModSummary -> FilePath

+ GHC.Driver.Types: msHsFilePath :: ModSummary -> FilePath

+ GHC.Driver.Types: msObjFilePath :: ModSummary -> FilePath

+ GHC.Driver.Types: ms_home_allimps :: ModSummary -> [ModuleName]

+ GHC.Driver.Types: ms_home_imps :: ModSummary -> [Located ModuleName]

+ GHC.Driver.Types: ms_home_srcimps :: ModSummary -> [Located ModuleName]

+ GHC.Driver.Types: ms_imps :: ModSummary -> [(Maybe FastString, Located ModuleName)]

+ GHC.Driver.Types: ms_installed_mod :: ModSummary -> InstalledModule

+ GHC.Driver.Types: ms_mod_name :: ModSummary -> ModuleName

+ GHC.Driver.Types: nameOfObject :: Unlinked -> FilePath

+ GHC.Driver.Types: needsTemplateHaskellOrQQ :: ModuleGraph -> Bool

+ GHC.Driver.Types: newtype Hsc a

+ GHC.Driver.Types: noDependencies :: Dependencies

+ GHC.Driver.Types: noIfaceTrustInfo :: IfaceTrustInfo

+ GHC.Driver.Types: numToTrustInfo :: Word8 -> IfaceTrustInfo

+ GHC.Driver.Types: phaseForeignLanguage :: Phase -> Maybe ForeignSrcLang

+ GHC.Driver.Types: pkgQual :: DynFlags -> PrintUnqualified

+ GHC.Driver.Types: plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv

+ GHC.Driver.Types: plusWarns :: Warnings -> Warnings -> Warnings

+ GHC.Driver.Types: pprHPT :: HomePackageTable -> SDoc

+ GHC.Driver.Types: pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc

+ GHC.Driver.Types: pprTarget :: Target -> SDoc

+ GHC.Driver.Types: pprTargetId :: TargetId -> SDoc

+ GHC.Driver.Types: prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv

+ GHC.Driver.Types: printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()

+ GHC.Driver.Types: renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName

+ GHC.Driver.Types: runHsc :: HscEnv -> Hsc a -> IO a

+ GHC.Driver.Types: runInteractiveHsc :: HscEnv -> Hsc a -> IO a

+ GHC.Driver.Types: setInteractivePackage :: HscEnv -> HscEnv

+ GHC.Driver.Types: setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext

+ GHC.Driver.Types: setSafeMode :: SafeHaskellMode -> IfaceTrustInfo

+ GHC.Driver.Types: showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String

+ GHC.Driver.Types: soExt :: Platform -> FilePath

+ GHC.Driver.Types: srcErrorMessages :: SourceError -> ErrorMessages

+ GHC.Driver.Types: substInteractiveContext :: InteractiveContext -> TCvSubst -> InteractiveContext

+ GHC.Driver.Types: throwErrors :: MonadIO io => ErrorMessages -> io a

+ GHC.Driver.Types: throwOneError :: MonadIO io => ErrMsg -> io a

+ GHC.Driver.Types: trustInfoToNum :: IfaceTrustInfo -> Word8

+ GHC.Driver.Types: tyThingAvailInfo :: TyThing -> [AvailInfo]

+ GHC.Driver.Types: tyThingCoAxiom :: HasDebugCallStack => TyThing -> CoAxiom Branched

+ GHC.Driver.Types: tyThingConLike :: HasDebugCallStack => TyThing -> ConLike

+ GHC.Driver.Types: tyThingDataCon :: HasDebugCallStack => TyThing -> DataCon

+ GHC.Driver.Types: tyThingId :: HasDebugCallStack => TyThing -> Id

+ GHC.Driver.Types: tyThingParent_maybe :: TyThing -> Maybe TyThing

+ GHC.Driver.Types: tyThingTyCon :: HasDebugCallStack => TyThing -> TyCon

+ GHC.Driver.Types: tyThingsTyCoVars :: [TyThing] -> TyCoVarSet

+ GHC.Driver.Types: type AnyHpcUsage = Bool

+ GHC.Driver.Types: type CompleteMatchMap = UniqFM [CompleteMatch]

+ GHC.Driver.Types: type FinderCache = InstalledModuleEnv InstalledFindResult

+ GHC.Driver.Types: type FixityEnv = NameEnv FixItem

+ GHC.Driver.Types: type HomePackageTable = DModuleNameEnv HomeModInfo

+ GHC.Driver.Types: type IfaceExport = AvailInfo

+ GHC.Driver.Types: type ImportedMods = ModuleEnv [ImportedBy]

+ GHC.Driver.Types: type InputFileBuffer = StringBuffer

+ GHC.Driver.Types: type IsBootInterface = Bool

+ GHC.Driver.Types: type IsSafeImport = Bool

+ GHC.Driver.Types: type MetaHook f = MetaRequest -> LHsExpr GhcTc -> f MetaResult

+ GHC.Driver.Types: type ModIface = ModIface_ 'ModIfaceFinal

+ GHC.Driver.Types: type PackageCompleteMatchMap = CompleteMatchMap

+ GHC.Driver.Types: type PackageFamInstEnv = FamInstEnv

+ GHC.Driver.Types: type PackageIfaceTable = ModuleEnv ModIface

+ GHC.Driver.Types: type PackageInstEnv = InstEnv

+ GHC.Driver.Types: type PackageRuleBase = RuleBase

+ GHC.Driver.Types: type PackageTypeEnv = TypeEnv

+ GHC.Driver.Types: type PartialModIface = ModIface_ 'ModIfaceCore

+ GHC.Driver.Types: type TypeEnv = NameEnv TyThing

+ GHC.Driver.Types: type WhetherHasOrphans = Bool

+ GHC.Driver.Types: typeEnvClasses :: TypeEnv -> [Class]

+ GHC.Driver.Types: typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]

+ GHC.Driver.Types: typeEnvDataCons :: TypeEnv -> [DataCon]

+ GHC.Driver.Types: typeEnvElts :: TypeEnv -> [TyThing]

+ GHC.Driver.Types: typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv

+ GHC.Driver.Types: typeEnvIds :: TypeEnv -> [Id]

+ GHC.Driver.Types: typeEnvPatSyns :: TypeEnv -> [PatSyn]

+ GHC.Driver.Types: typeEnvTyCons :: TypeEnv -> [TyCon]

+ GHC.Driver.Types: updNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c

+ GHC.Hs.Decls: familyDeclLName :: FamilyDecl (GhcPass p) -> Located (IdP (GhcPass p))

+ GHC.Hs.Decls: familyDeclName :: FamilyDecl (GhcPass p) -> IdP (GhcPass p)

+ GHC.Hs.Expr: NoSyntaxExprRn :: SyntaxExprRn

+ GHC.Hs.Expr: NoSyntaxExprTc :: SyntaxExprTc

+ GHC.Hs.Expr: SyntaxExprRn :: HsExpr GhcRn -> SyntaxExprRn

+ GHC.Hs.Expr: SyntaxExprTc :: HsExpr GhcTc -> [HsWrapper] -> HsWrapper -> SyntaxExprTc

+ GHC.Hs.Expr: data HsWrap hs_syn

+ GHC.Hs.Expr: data SyntaxExprRn

+ GHC.Hs.Expr: data SyntaxExprTc

+ GHC.Hs.Expr: instance (Data.Data.Data (hs_syn GHC.Hs.Extension.GhcTc), Data.Typeable.Internal.Typeable hs_syn) => Data.Data.Data (GHC.Hs.Expr.HsWrap hs_syn)

+ GHC.Hs.Expr: instance Data.Data.Data (GHC.Hs.Expr.HsMatchContext GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Expr: instance Data.Data.Data (GHC.Hs.Expr.HsMatchContext GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Expr: instance Data.Data.Data (GHC.Hs.Expr.HsStmtContext GHC.Hs.Extension.GhcPs)

+ GHC.Hs.Expr: instance Data.Data.Data (GHC.Hs.Expr.HsStmtContext GHC.Hs.Extension.GhcRn)

+ GHC.Hs.Expr: instance Data.Data.Data GHC.Hs.Expr.HsSplicedT

+ GHC.Hs.Expr: instance GHC.Hs.Extension.OutputableBndrId p => Outputable.Outputable (GHC.Hs.Expr.HsMatchContext (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Expr: instance GHC.Hs.Extension.OutputableBndrId p => Outputable.Outputable (GHC.Hs.Expr.HsStmtContext (GHC.Hs.Extension.GhcPass p))

+ GHC.Hs.Expr: instance Outputable.Outputable GHC.Hs.Expr.SyntaxExprRn

+ GHC.Hs.Expr: instance Outputable.Outputable GHC.Hs.Expr.SyntaxExprTc

+ GHC.Hs.Expr: newtype HsSplicedT

+ GHC.Hs.Expr: type family SyntaxExprGhc (p :: Pass) = (r :: Type) | r -> p

+ GHC.Hs.Extension: [GhcPs] :: GhcPs

+ GHC.Hs.Extension: [GhcRn] :: GhcRn

+ GHC.Hs.Extension: [GhcTc] :: GhcTc

+ GHC.Hs.Extension: class (NoGhcTcPass (NoGhcTcPass p) ~ NoGhcTcPass p, IsPass (NoGhcTcPass p)) => IsPass p

+ GHC.Hs.Extension: ghcPass :: IsPass p => GhcPass p

+ GHC.Hs.Extension: instance Data.Typeable.Internal.Typeable p => Data.Data.Data (GHC.Hs.Extension.GhcPass p)

+ GHC.Hs.Extension: instance GHC.Hs.Extension.IsPass 'GHC.Hs.Extension.Parsed

+ GHC.Hs.Extension: instance GHC.Hs.Extension.IsPass 'GHC.Hs.Extension.Renamed

+ GHC.Hs.Extension: instance GHC.Hs.Extension.IsPass 'GHC.Hs.Extension.Typechecked

+ GHC.Hs.Extension: pprIfPs :: forall p. IsPass p => (p ~ 'Parsed => SDoc) -> SDoc

+ GHC.Hs.Extension: pprIfRn :: forall p. IsPass p => (p ~ 'Renamed => SDoc) -> SDoc

+ GHC.Hs.Extension: pprIfTc :: forall p. IsPass p => (p ~ 'Typechecked => SDoc) -> SDoc

+ GHC.Hs.Instances: instance Data.Data.Data GHC.Hs.Expr.RecordUpdTc

+ GHC.Hs.Instances: instance Data.Data.Data GHC.Hs.Expr.SyntaxExprRn

+ GHC.Hs.Instances: instance Data.Data.Data GHC.Hs.Expr.SyntaxExprTc

+ GHC.Hs.Pat: isSimplePat :: LPat (GhcPass x) -> Maybe (IdP (GhcPass x))

+ GHC.Hs.Utils: nl_HsVar :: IdP (GhcPass id) -> HsExpr (GhcPass id)

+ GHC.HsToCore.PmCheck.Types: MkDeltas :: Bag Delta -> Deltas

+ GHC.HsToCore.PmCheck.Types: initDeltas :: Deltas

+ GHC.HsToCore.PmCheck.Types: instance GHC.Base.Semigroup GHC.HsToCore.PmCheck.Types.Deltas

+ GHC.HsToCore.PmCheck.Types: instance Outputable.Outputable GHC.HsToCore.PmCheck.Types.Deltas

+ GHC.HsToCore.PmCheck.Types: liftDeltasM :: Monad m => (Delta -> m (Maybe Delta)) -> Deltas -> m Deltas

+ GHC.HsToCore.PmCheck.Types: newtype Deltas

+ GHC.Iface.Syntax: HsCpr :: CprSig -> IfaceInfoItem

+ GHC.Iface.Syntax: type IfaceIdInfo = [IfaceInfoItem]

+ GHC.Iface.Type: PrintExplicitKinds :: Bool -> PrintExplicitKinds

+ GHC.Iface.Type: instance Outputable.Outputable GHC.Iface.Type.IfaceTyConInfo

+ GHC.Iface.Type: instance Outputable.Outputable GHC.Iface.Type.IfaceTyConSort

+ GHC.Iface.Type: newtype PrintExplicitKinds

+ GHC.Platform.Reg: RealRegPair :: {-# UNPACK #-} !RegNo -> {-# UNPACK #-} !RegNo -> RealReg

+ GHC.Platform.Reg: RealRegSingle :: {-# UNPACK #-} !RegNo -> RealReg

+ GHC.Platform.Reg: RegReal :: !RealReg -> Reg

+ GHC.Platform.Reg: RegVirtual :: !VirtualReg -> Reg

+ GHC.Platform.Reg: VirtualRegD :: {-# UNPACK #-} !Unique -> VirtualReg

+ GHC.Platform.Reg: VirtualRegF :: {-# UNPACK #-} !Unique -> VirtualReg

+ GHC.Platform.Reg: VirtualRegHi :: {-# UNPACK #-} !Unique -> VirtualReg

+ GHC.Platform.Reg: VirtualRegI :: {-# UNPACK #-} !Unique -> VirtualReg

+ GHC.Platform.Reg: classOfVirtualReg :: VirtualReg -> RegClass

+ GHC.Platform.Reg: data RealReg

+ GHC.Platform.Reg: data Reg

+ GHC.Platform.Reg: data VirtualReg

+ GHC.Platform.Reg: getHiVRegFromLo :: Reg -> Reg

+ GHC.Platform.Reg: getHiVirtualRegFromLo :: VirtualReg -> VirtualReg

+ GHC.Platform.Reg: instance GHC.Classes.Eq GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance GHC.Classes.Eq GHC.Platform.Reg.Reg

+ GHC.Platform.Reg: instance GHC.Classes.Eq GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg: instance GHC.Classes.Ord GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance GHC.Classes.Ord GHC.Platform.Reg.Reg

+ GHC.Platform.Reg: instance GHC.Classes.Ord GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg: instance GHC.Show.Show GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance GHC.Show.Show GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg: instance Outputable.Outputable GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance Outputable.Outputable GHC.Platform.Reg.Reg

+ GHC.Platform.Reg: instance Outputable.Outputable GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg: instance Unique.Uniquable GHC.Platform.Reg.RealReg

+ GHC.Platform.Reg: instance Unique.Uniquable GHC.Platform.Reg.Reg

+ GHC.Platform.Reg: instance Unique.Uniquable GHC.Platform.Reg.VirtualReg

+ GHC.Platform.Reg: isRealReg :: Reg -> Bool

+ GHC.Platform.Reg: isVirtualReg :: Reg -> Bool

+ GHC.Platform.Reg: liftPatchFnToRegReg :: (VirtualReg -> RealReg) -> Reg -> Reg

+ GHC.Platform.Reg: realRegsAlias :: RealReg -> RealReg -> Bool

+ GHC.Platform.Reg: regNosOfRealReg :: RealReg -> [RegNo]

+ GHC.Platform.Reg: regPair :: RegNo -> RegNo -> Reg

+ GHC.Platform.Reg: regSingle :: RegNo -> Reg

+ GHC.Platform.Reg: renameVirtualReg :: Unique -> VirtualReg -> VirtualReg

+ GHC.Platform.Reg: takeRealReg :: Reg -> Maybe RealReg

+ GHC.Platform.Reg: takeVirtualReg :: Reg -> Maybe VirtualReg

+ GHC.Platform.Reg: type RegNo = Int

+ GHC.Platform.Reg.Class: RcDouble :: RegClass

+ GHC.Platform.Reg.Class: RcFloat :: RegClass

+ GHC.Platform.Reg.Class: RcInteger :: RegClass

+ GHC.Platform.Reg.Class: data RegClass

+ GHC.Platform.Reg.Class: instance GHC.Classes.Eq GHC.Platform.Reg.Class.RegClass

+ GHC.Platform.Reg.Class: instance Outputable.Outputable GHC.Platform.Reg.Class.RegClass

+ GHC.Platform.Reg.Class: instance Unique.Uniquable GHC.Platform.Reg.Class.RegClass

+ GHC.Runtime.Eval.Types: BreakInfo :: Module -> Int -> BreakInfo

+ GHC.Runtime.Eval.Types: ExecBreak :: [Name] -> Maybe BreakInfo -> ExecResult

+ GHC.Runtime.Eval.Types: ExecComplete :: Either SomeException [Name] -> Word64 -> ExecResult

+ GHC.Runtime.Eval.Types: ExecOptions :: SingleStep -> String -> Int -> (ForeignHValue -> EvalExpr ForeignHValue) -> ExecOptions

+ GHC.Runtime.Eval.Types: History :: ForeignHValue -> BreakInfo -> [String] -> History

+ GHC.Runtime.Eval.Types: Resume :: String -> ForeignRef (ResumeContext [HValueRef]) -> ([TyThing], GlobalRdrEnv) -> [Id] -> ForeignHValue -> Maybe BreakInfo -> SrcSpan -> String -> RemotePtr CostCentreStack -> [History] -> Int -> Resume

+ GHC.Runtime.Eval.Types: RunAndLogSteps :: SingleStep

+ GHC.Runtime.Eval.Types: RunToCompletion :: SingleStep

+ GHC.Runtime.Eval.Types: SingleStep :: SingleStep

+ GHC.Runtime.Eval.Types: [breakInfo] :: ExecResult -> Maybe BreakInfo

+ GHC.Runtime.Eval.Types: [breakInfo_module] :: BreakInfo -> Module

+ GHC.Runtime.Eval.Types: [breakInfo_number] :: BreakInfo -> Int

+ GHC.Runtime.Eval.Types: [breakNames] :: ExecResult -> [Name]

+ GHC.Runtime.Eval.Types: [execAllocation] :: ExecResult -> Word64

+ GHC.Runtime.Eval.Types: [execLineNumber] :: ExecOptions -> Int

+ GHC.Runtime.Eval.Types: [execResult] :: ExecResult -> Either SomeException [Name]

+ GHC.Runtime.Eval.Types: [execSingleStep] :: ExecOptions -> SingleStep

+ GHC.Runtime.Eval.Types: [execSourceFile] :: ExecOptions -> String

+ GHC.Runtime.Eval.Types: [execWrap] :: ExecOptions -> ForeignHValue -> EvalExpr ForeignHValue

+ GHC.Runtime.Eval.Types: [historyApStack] :: History -> ForeignHValue

+ GHC.Runtime.Eval.Types: [historyBreakInfo] :: History -> BreakInfo

+ GHC.Runtime.Eval.Types: [historyEnclosingDecls] :: History -> [String]

+ GHC.Runtime.Eval.Types: [resumeApStack] :: Resume -> ForeignHValue

+ GHC.Runtime.Eval.Types: [resumeBindings] :: Resume -> ([TyThing], GlobalRdrEnv)

+ GHC.Runtime.Eval.Types: [resumeBreakInfo] :: Resume -> Maybe BreakInfo

+ GHC.Runtime.Eval.Types: [resumeCCS] :: Resume -> RemotePtr CostCentreStack

+ GHC.Runtime.Eval.Types: [resumeContext] :: Resume -> ForeignRef (ResumeContext [HValueRef])

+ GHC.Runtime.Eval.Types: [resumeDecl] :: Resume -> String

+ GHC.Runtime.Eval.Types: [resumeFinalIds] :: Resume -> [Id]

+ GHC.Runtime.Eval.Types: [resumeHistoryIx] :: Resume -> Int

+ GHC.Runtime.Eval.Types: [resumeHistory] :: Resume -> [History]

+ GHC.Runtime.Eval.Types: [resumeSpan] :: Resume -> SrcSpan

+ GHC.Runtime.Eval.Types: [resumeStmt] :: Resume -> String

+ GHC.Runtime.Eval.Types: data BreakInfo

+ GHC.Runtime.Eval.Types: data ExecOptions

+ GHC.Runtime.Eval.Types: data ExecResult

+ GHC.Runtime.Eval.Types: data History

+ GHC.Runtime.Eval.Types: data Resume

+ GHC.Runtime.Eval.Types: data SingleStep

+ GHC.Runtime.Eval.Types: isStep :: SingleStep -> Bool

+ GHC.Runtime.Heap.Layout: ArgGen :: Liveness -> ArgDescr

+ GHC.Runtime.Heap.Layout: ArgSpec :: !Int -> ArgDescr

+ GHC.Runtime.Heap.Layout: ArrayPtrsRep :: !WordOff -> !WordOff -> SMRep

+ GHC.Runtime.Heap.Layout: ArrayWordsRep :: !WordOff -> SMRep

+ GHC.Runtime.Heap.Layout: BlackHole :: ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: Constr :: ConTagZ -> ConstrDescription -> ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: Fun :: FunArity -> ArgDescr -> ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: HeapRep :: IsStatic -> !WordOff -> !WordOff -> ClosureTypeInfo -> SMRep

+ GHC.Runtime.Heap.Layout: IndStatic :: ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: RTSRep :: Int -> SMRep -> SMRep

+ GHC.Runtime.Heap.Layout: SmallArrayPtrsRep :: !WordOff -> SMRep

+ GHC.Runtime.Heap.Layout: StackRep :: Liveness -> SMRep

+ GHC.Runtime.Heap.Layout: Thunk :: ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: ThunkSelector :: SelectorOffset -> ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: aRG_GEN :: Int

+ GHC.Runtime.Heap.Layout: aRG_GEN_BIG :: Int

+ GHC.Runtime.Heap.Layout: arrPtrsHdrSize :: DynFlags -> ByteOff

+ GHC.Runtime.Heap.Layout: arrPtrsHdrSizeW :: DynFlags -> WordOff

+ GHC.Runtime.Heap.Layout: arrPtrsRep :: DynFlags -> WordOff -> SMRep

+ GHC.Runtime.Heap.Layout: arrWordsHdrSize :: DynFlags -> ByteOff

+ GHC.Runtime.Heap.Layout: arrWordsHdrSizeW :: DynFlags -> WordOff

+ GHC.Runtime.Heap.Layout: arrWordsRep :: DynFlags -> ByteOff -> SMRep

+ GHC.Runtime.Heap.Layout: blackHoleRep :: SMRep

+ GHC.Runtime.Heap.Layout: bytesToWordsRoundUp :: DynFlags -> ByteOff -> WordOff

+ GHC.Runtime.Heap.Layout: card :: DynFlags -> Int -> Int

+ GHC.Runtime.Heap.Layout: cardRoundUp :: DynFlags -> Int -> Int

+ GHC.Runtime.Heap.Layout: cardTableSizeB :: DynFlags -> Int -> ByteOff

+ GHC.Runtime.Heap.Layout: cardTableSizeW :: DynFlags -> Int -> WordOff

+ GHC.Runtime.Heap.Layout: data ArgDescr

+ GHC.Runtime.Heap.Layout: data ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: data SMRep

+ GHC.Runtime.Heap.Layout: data StgHalfWord

+ GHC.Runtime.Heap.Layout: data StgWord

+ GHC.Runtime.Heap.Layout: fixedHdrSize :: DynFlags -> ByteOff

+ GHC.Runtime.Heap.Layout: fixedHdrSizeW :: DynFlags -> WordOff

+ GHC.Runtime.Heap.Layout: fromStgHalfWord :: StgHalfWord -> Integer

+ GHC.Runtime.Heap.Layout: fromStgWord :: StgWord -> Integer

+ GHC.Runtime.Heap.Layout: halfWordSize :: DynFlags -> ByteOff

+ GHC.Runtime.Heap.Layout: halfWordSizeInBits :: DynFlags -> Int

+ GHC.Runtime.Heap.Layout: hdrSize :: DynFlags -> SMRep -> ByteOff

+ GHC.Runtime.Heap.Layout: hdrSizeW :: DynFlags -> SMRep -> WordOff

+ GHC.Runtime.Heap.Layout: heapClosureSizeW :: DynFlags -> SMRep -> WordOff

+ GHC.Runtime.Heap.Layout: indStaticRep :: SMRep

+ GHC.Runtime.Heap.Layout: instance Data.Bits.Bits GHC.Runtime.Heap.Layout.StgWord

+ GHC.Runtime.Heap.Layout: instance GHC.Classes.Eq GHC.Runtime.Heap.Layout.StgHalfWord

+ GHC.Runtime.Heap.Layout: instance GHC.Classes.Eq GHC.Runtime.Heap.Layout.StgWord

+ GHC.Runtime.Heap.Layout: instance Outputable.Outputable GHC.Runtime.Heap.Layout.ArgDescr

+ GHC.Runtime.Heap.Layout: instance Outputable.Outputable GHC.Runtime.Heap.Layout.ClosureTypeInfo

+ GHC.Runtime.Heap.Layout: instance Outputable.Outputable GHC.Runtime.Heap.Layout.SMRep

+ GHC.Runtime.Heap.Layout: instance Outputable.Outputable GHC.Runtime.Heap.Layout.StgHalfWord

+ GHC.Runtime.Heap.Layout: instance Outputable.Outputable GHC.Runtime.Heap.Layout.StgWord

+ GHC.Runtime.Heap.Layout: isConRep :: SMRep -> Bool

+ GHC.Runtime.Heap.Layout: isFunRep :: SMRep -> Bool

+ GHC.Runtime.Heap.Layout: isStackRep :: SMRep -> Bool

+ GHC.Runtime.Heap.Layout: isStaticNoCafCon :: SMRep -> Bool

+ GHC.Runtime.Heap.Layout: isStaticRep :: SMRep -> IsStatic

+ GHC.Runtime.Heap.Layout: isThunkRep :: SMRep -> Bool

+ GHC.Runtime.Heap.Layout: mkHeapRep :: DynFlags -> IsStatic -> WordOff -> WordOff -> ClosureTypeInfo -> SMRep

+ GHC.Runtime.Heap.Layout: mkRTSRep :: Int -> SMRep -> SMRep

+ GHC.Runtime.Heap.Layout: mkStackRep :: [Bool] -> SMRep

+ GHC.Runtime.Heap.Layout: nonHdrSize :: DynFlags -> SMRep -> ByteOff

+ GHC.Runtime.Heap.Layout: nonHdrSizeW :: SMRep -> WordOff

+ GHC.Runtime.Heap.Layout: profHdrSize :: DynFlags -> WordOff

+ GHC.Runtime.Heap.Layout: rET_BIG :: Int

+ GHC.Runtime.Heap.Layout: rET_SMALL :: Int

+ GHC.Runtime.Heap.Layout: roundUpTo :: ByteOff -> ByteOff -> ByteOff

+ GHC.Runtime.Heap.Layout: roundUpToWords :: DynFlags -> ByteOff -> ByteOff

+ GHC.Runtime.Heap.Layout: rtsClosureType :: SMRep -> Int

+ GHC.Runtime.Heap.Layout: smallArrPtrsHdrSize :: DynFlags -> ByteOff

+ GHC.Runtime.Heap.Layout: smallArrPtrsHdrSizeW :: DynFlags -> WordOff

+ GHC.Runtime.Heap.Layout: smallArrPtrsRep :: WordOff -> SMRep

+ GHC.Runtime.Heap.Layout: thunkHdrSize :: DynFlags -> WordOff

+ GHC.Runtime.Heap.Layout: toStgHalfWord :: DynFlags -> Integer -> StgHalfWord

+ GHC.Runtime.Heap.Layout: toStgWord :: DynFlags -> Integer -> StgWord

+ GHC.Runtime.Heap.Layout: type ByteOff = Int

+ GHC.Runtime.Heap.Layout: type ConstrDescription = ByteString

+ GHC.Runtime.Heap.Layout: type IsStatic = Bool

+ GHC.Runtime.Heap.Layout: type Liveness = [Bool]

+ GHC.Runtime.Heap.Layout: type WordOff = Int

+ GHC.Runtime.Heap.Layout: wordsToBytes :: Num a => DynFlags -> a -> a

+ GHC.Runtime.Interpreter.Types: ExternalInterp :: !IServ -> Interp

+ GHC.Runtime.Interpreter.Types: IServ :: MVar IServState -> IServ

+ GHC.Runtime.Interpreter.Types: IServConfig :: !String -> ![String] -> !Maybe (CreateProcess -> IO ProcessHandle) -> IO () -> IServConfig

+ GHC.Runtime.Interpreter.Types: IServInstance :: !Pipe -> !ProcessHandle -> !UniqFM (Ptr ()) -> ![HValueRef] -> !IServConfig -> IServInstance

+ GHC.Runtime.Interpreter.Types: IServPending :: !IServConfig -> IServState

+ GHC.Runtime.Interpreter.Types: IServRunning :: !IServInstance -> IServState

+ GHC.Runtime.Interpreter.Types: [iservConfHook] :: IServConfig -> !Maybe (CreateProcess -> IO ProcessHandle)

+ GHC.Runtime.Interpreter.Types: [iservConfOpts] :: IServConfig -> ![String]

+ GHC.Runtime.Interpreter.Types: [iservConfProgram] :: IServConfig -> !String

+ GHC.Runtime.Interpreter.Types: [iservConfTrace] :: IServConfig -> IO ()

+ GHC.Runtime.Interpreter.Types: [iservConfig] :: IServInstance -> !IServConfig

+ GHC.Runtime.Interpreter.Types: [iservLookupSymbolCache] :: IServInstance -> !UniqFM (Ptr ())

+ GHC.Runtime.Interpreter.Types: [iservPendingFrees] :: IServInstance -> ![HValueRef]

+ GHC.Runtime.Interpreter.Types: [iservPipe] :: IServInstance -> !Pipe

+ GHC.Runtime.Interpreter.Types: [iservProcess] :: IServInstance -> !ProcessHandle

+ GHC.Runtime.Interpreter.Types: data IServConfig

+ GHC.Runtime.Interpreter.Types: data IServInstance

+ GHC.Runtime.Interpreter.Types: data IServState

+ GHC.Runtime.Interpreter.Types: data Interp

+ GHC.Runtime.Interpreter.Types: newtype IServ

+ GHC.Runtime.Linker.Types: BCOs :: CompiledByteCode -> [SptEntry] -> Unlinked

+ GHC.Runtime.Linker.Types: DotA :: FilePath -> Unlinked

+ GHC.Runtime.Linker.Types: DotDLL :: FilePath -> Unlinked

+ GHC.Runtime.Linker.Types: DotO :: FilePath -> Unlinked

+ GHC.Runtime.Linker.Types: DynLinker :: MVar (Maybe PersistentLinkerState) -> DynLinker

+ GHC.Runtime.Linker.Types: LM :: UTCTime -> Module -> [Unlinked] -> Linkable

+ GHC.Runtime.Linker.Types: PersistentLinkerState :: ClosureEnv -> !ItblEnv -> ![Linkable] -> ![Linkable] -> ![LinkerUnitId] -> ![(FilePath, String)] -> PersistentLinkerState

+ GHC.Runtime.Linker.Types: SptEntry :: Id -> Fingerprint -> SptEntry

+ GHC.Runtime.Linker.Types: [bcos_loaded] :: PersistentLinkerState -> ![Linkable]

+ GHC.Runtime.Linker.Types: [closure_env] :: PersistentLinkerState -> ClosureEnv

+ GHC.Runtime.Linker.Types: [dl_mpls] :: DynLinker -> MVar (Maybe PersistentLinkerState)

+ GHC.Runtime.Linker.Types: [itbl_env] :: PersistentLinkerState -> !ItblEnv

+ GHC.Runtime.Linker.Types: [linkableModule] :: Linkable -> Module

+ GHC.Runtime.Linker.Types: [linkableTime] :: Linkable -> UTCTime

+ GHC.Runtime.Linker.Types: [linkableUnlinked] :: Linkable -> [Unlinked]

+ GHC.Runtime.Linker.Types: [objs_loaded] :: PersistentLinkerState -> ![Linkable]

+ GHC.Runtime.Linker.Types: [pkgs_loaded] :: PersistentLinkerState -> ![LinkerUnitId]

+ GHC.Runtime.Linker.Types: [temp_sos] :: PersistentLinkerState -> ![(FilePath, String)]

+ GHC.Runtime.Linker.Types: data Linkable

+ GHC.Runtime.Linker.Types: data PersistentLinkerState

+ GHC.Runtime.Linker.Types: data SptEntry

+ GHC.Runtime.Linker.Types: data Unlinked

+ GHC.Runtime.Linker.Types: instance Outputable.Outputable GHC.Runtime.Linker.Types.Linkable

+ GHC.Runtime.Linker.Types: instance Outputable.Outputable GHC.Runtime.Linker.Types.SptEntry

+ GHC.Runtime.Linker.Types: instance Outputable.Outputable GHC.Runtime.Linker.Types.Unlinked

+ GHC.Runtime.Linker.Types: newtype DynLinker

+ GHC.Runtime.Linker.Types: type LinkerUnitId = InstalledUnitId

+ GHC.Stg.Syntax: bindersOf :: BinderP a ~ Id => GenStgBinding a -> [Id]

+ GHC.Stg.Syntax: bindersOfTop :: BinderP a ~ Id => GenStgTopBinding a -> [Id]

+ GHC.Stg.Syntax: bindersOfTopBinds :: BinderP a ~ Id => [GenStgTopBinding a] -> [Id]

+ IOEnv: instance GHC.Driver.Session.ContainsDynFlags env => GHC.Driver.Session.HasDynFlags (IOEnv.IOEnv env)

+ Id: idCprInfo :: Id -> CprSig

+ Id: setIdCprInfo :: Id -> CprSig -> Id

+ IdInfo: cprInfo :: IdInfo -> CprSig

+ IdInfo: setCprInfo :: IdInfo -> CprSig -> IdInfo

+ Lexer: [eof_pos] :: PState -> Maybe RealSrcSpan

+ Lexer: failMsgP :: String -> P a

+ MkId: vanillaDataConBoxer :: DataConBoxer

+ Outputable: SDC :: !PprStyle -> !Scheme -> !PprColour -> !Bool -> !Int -> !Bool -> !Bool -> !Int -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> !Bool -> DynFlags -> SDocContext

+ Outputable: [sdocCanUseUnicode] :: SDocContext -> !Bool

+ Outputable: [sdocColScheme] :: SDocContext -> !Scheme

+ Outputable: [sdocDebugLevel] :: SDocContext -> !Int

+ Outputable: [sdocDynFlags] :: SDocContext -> DynFlags

+ Outputable: [sdocErrorSpans] :: SDocContext -> !Bool

+ Outputable: [sdocHexWordLiterals] :: SDocContext -> !Bool

+ Outputable: [sdocImpredicativeTypes] :: SDocContext -> !Bool

+ Outputable: [sdocLastColour] :: SDocContext -> !PprColour

+ Outputable: [sdocLineLength] :: SDocContext -> !Int

+ Outputable: [sdocPprDebug] :: SDocContext -> !Bool

+ Outputable: [sdocPrintAxiomIncomps] :: SDocContext -> !Bool

+ Outputable: [sdocPrintCaseAsLet] :: SDocContext -> !Bool

+ Outputable: [sdocPrintEqualityRelations] :: SDocContext -> !Bool

+ Outputable: [sdocPrintExplicitCoercions] :: SDocContext -> !Bool

+ Outputable: [sdocPrintExplicitForalls] :: SDocContext -> !Bool

+ Outputable: [sdocPrintExplicitKinds] :: SDocContext -> !Bool

+ Outputable: [sdocPrintExplicitRuntimeReps] :: SDocContext -> !Bool

+ Outputable: [sdocPrintPotentialInstances] :: SDocContext -> !Bool

+ Outputable: [sdocPrintTypecheckerElaboration] :: SDocContext -> !Bool

+ Outputable: [sdocPrintUnicodeSyntax] :: SDocContext -> !Bool

+ Outputable: [sdocShouldUseColor] :: SDocContext -> !Bool

+ Outputable: [sdocStarIsType] :: SDocContext -> !Bool

+ Outputable: [sdocStyle] :: SDocContext -> !PprStyle

+ Outputable: [sdocSuppressCoercions] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressIdInfo] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressModulePrefixes] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressStgExts] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressTicks] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressTypeApplications] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressTypeSignatures] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressUnfoldings] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressUniques] :: SDocContext -> !Bool

+ Outputable: [sdocSuppressVarKinds] :: SDocContext -> !Bool

+ Outputable: data SDocContext

+ Outputable: ppUnlessOption :: (SDocContext -> Bool) -> SDoc -> SDoc

+ Outputable: ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc

+ Outputable: sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc

+ Outputable: sdocWithContext :: (SDocContext -> SDoc) -> SDoc

+ Outputable: updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc

+ Outputable: withErrStyle :: PrintUnqualified -> SDoc -> SDoc

+ Outputable: withUserStyle :: PrintUnqualified -> Depth -> SDoc -> SDoc

+ PrelNames: dATA_LIST :: Module

+ PrelNames: uNSAFE_COERCE :: Module

+ PrelNames: unsafeCoerceName :: Name

+ PrelNames: unsafeCoercePrimIdKey :: Unique

+ PrelNames: unsafeCoercePrimName :: Name

+ PrelNames: unsafeEqualityProofIdKey :: Unique

+ PrelNames: unsafeEqualityProofName :: Name

+ PrelNames: unsafeEqualityTyConKey :: Unique

+ PrelNames: unsafeEqualityTyConName :: Name

+ PrelNames: unsafeReflDataConKey :: Unique

+ PrelNames: unsafeReflDataConName :: Name

+ PrelRules: instance GHC.Driver.Session.HasDynFlags PrelRules.RuleM

+ PrimOp: RaiseDivZeroOp :: PrimOp

+ PrimOp: RaiseOverflowOp :: PrimOp

+ PrimOp: RaiseUnderflowOp :: PrimOp

+ SrcLoc: BufPos :: Int -> BufPos

+ SrcLoc: BufSpan :: {-# UNPACK #-} !BufPos -> BufSpan

+ SrcLoc: PsLoc :: !RealSrcLoc -> !BufPos -> PsLoc

+ SrcLoc: PsSpan :: !RealSrcSpan -> !BufSpan -> PsSpan

+ SrcLoc: [bufPos] :: BufPos -> Int

+ SrcLoc: [bufSpanStart, bufSpanEnd] :: BufSpan -> {-# UNPACK #-} !BufPos

+ SrcLoc: [psBufPos] :: PsLoc -> !BufPos

+ SrcLoc: [psBufSpan] :: PsSpan -> !BufSpan

+ SrcLoc: [psRealLoc] :: PsLoc -> !RealSrcLoc

+ SrcLoc: [psRealSpan] :: PsSpan -> !RealSrcSpan

+ SrcLoc: advanceBufPos :: BufPos -> BufPos

+ SrcLoc: advancePsLoc :: PsLoc -> Char -> PsLoc

+ SrcLoc: data BufSpan

+ SrcLoc: data PsLoc

+ SrcLoc: data PsSpan

+ SrcLoc: instance GHC.Classes.Eq SrcLoc.BufPos

+ SrcLoc: instance GHC.Classes.Eq SrcLoc.BufSpan

+ SrcLoc: instance GHC.Classes.Eq SrcLoc.PsLoc

+ SrcLoc: instance GHC.Classes.Eq SrcLoc.PsSpan

+ SrcLoc: instance GHC.Classes.Ord SrcLoc.BufPos

+ SrcLoc: instance GHC.Classes.Ord SrcLoc.BufSpan

+ SrcLoc: instance GHC.Classes.Ord SrcLoc.PsLoc

+ SrcLoc: instance GHC.Classes.Ord SrcLoc.PsSpan

+ SrcLoc: instance GHC.Show.Show SrcLoc.BufPos

+ SrcLoc: instance GHC.Show.Show SrcLoc.BufSpan

+ SrcLoc: instance GHC.Show.Show SrcLoc.PsLoc

+ SrcLoc: instance GHC.Show.Show SrcLoc.PsSpan

+ SrcLoc: isRealSubspanOf :: RealSrcSpan -> RealSrcSpan -> Bool

+ SrcLoc: lookupSrcLoc :: SrcLoc -> Map RealSrcLoc a -> Maybe a

+ SrcLoc: lookupSrcSpan :: SrcSpan -> Map RealSrcSpan a -> Maybe a

+ SrcLoc: mkPsSpan :: PsLoc -> PsLoc -> PsSpan

+ SrcLoc: mkSrcSpanPs :: PsSpan -> SrcSpan

+ SrcLoc: newtype BufPos

+ SrcLoc: psSpanEnd :: PsSpan -> PsLoc

+ SrcLoc: psSpanStart :: PsSpan -> PsLoc

+ SrcLoc: rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering

+ SrcLoc: sortRealLocated :: [RealLocated a] -> [RealLocated a]

+ SrcLoc: type PsLocated = GenLocated PsSpan

+ TcOrigin: RuntimeUnkSkol :: SkolemInfo

+ TcRnTypes: [dsl_deltas] :: DsLclEnv -> Deltas

+ TcRnTypes: instance GHC.Driver.Session.ContainsDynFlags (TcRnTypes.Env gbl lcl)

+ TyCoFVs: Endo :: (a -> a) -> Endo a

+ TyCoFVs: [appEndo] :: Endo a -> a -> a

+ TyCoFVs: closeOverKinds :: TyCoVarSet -> TyCoVarSet

+ TyCoFVs: closeOverKindsDSet :: DTyVarSet -> DTyVarSet

+ TyCoFVs: closeOverKindsList :: [TyVar] -> [TyVar]

+ TyCoFVs: deepTcvFolder :: TyCoFolder TyCoVarSet (Endo TyCoVarSet)

+ TyCoFVs: newtype Endo a

+ TyCoFVs: runTyCoVars :: Endo TyCoVarSet -> TyCoVarSet

+ TyCoFVs: shallowTyCoVarsOfCo :: Coercion -> TyCoVarSet

+ TyCoFVs: shallowTyCoVarsOfCoVarEnv :: CoVarEnv Coercion -> TyCoVarSet

+ TyCoFVs: shallowTyCoVarsOfCos :: [Coercion] -> TyCoVarSet

+ TyCoFVs: shallowTyCoVarsOfTyVarEnv :: TyVarEnv Type -> TyCoVarSet

+ TyCoFVs: shallowTyCoVarsOfType :: Type -> TyCoVarSet

+ TyCoFVs: shallowTyCoVarsOfTypes :: [Type] -> TyCoVarSet

+ TyCoRep: TyCoFolder :: (Type -> Maybe Type) -> (env -> TyVar -> a) -> (env -> CoVar -> a) -> (env -> CoercionHole -> a) -> (env -> TyCoVar -> ArgFlag -> env) -> TyCoFolder env a

+ TyCoRep: [tcf_covar] :: TyCoFolder env a -> env -> CoVar -> a

+ TyCoRep: [tcf_hole] :: TyCoFolder env a -> env -> CoercionHole -> a

+ TyCoRep: [tcf_tycobinder] :: TyCoFolder env a -> env -> TyCoVar -> ArgFlag -> env

+ TyCoRep: [tcf_tyvar] :: TyCoFolder env a -> env -> TyVar -> a

+ TyCoRep: [tcf_view] :: TyCoFolder env a -> Type -> Maybe Type

+ TyCoRep: data TyCoFolder env a

+ TyCoRep: foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)

+ TyCon: instance Outputable.OutputableBndr tv => Outputable.Outputable (Var.VarBndr tv TyCon.TyConBndrVis)

+ Type: TyCoFolder :: (Type -> Maybe Type) -> (env -> TyVar -> a) -> (env -> CoVar -> a) -> (env -> CoercionHole -> a) -> (env -> TyCoVar -> ArgFlag -> env) -> TyCoFolder env a

+ Type: [tcf_covar] :: TyCoFolder env a -> env -> CoVar -> a

+ Type: [tcf_hole] :: TyCoFolder env a -> env -> CoercionHole -> a

+ Type: [tcf_tycobinder] :: TyCoFolder env a -> env -> TyCoVar -> ArgFlag -> env

+ Type: [tcf_tyvar] :: TyCoFolder env a -> env -> TyVar -> a

+ Type: [tcf_view] :: TyCoFolder env a -> Type -> Maybe Type

+ Type: buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind -> [Role] -> KnotTied Type -> TyCon

+ Type: data TyCoFolder env a

+ Type: foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)

+ Util: strictMap :: (a -> b) -> [a] -> [b]

+ VarSet: nonDetFoldVarSet :: (Var -> a -> a) -> a -> VarSet -> a

- ApiAnnotation: getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)

+ ApiAnnotation: getAndRemoveAnnotation :: ApiAnns -> RealSrcSpan -> AnnKeywordId -> ([RealSrcSpan], ApiAnns)

- ApiAnnotation: getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)

+ ApiAnnotation: getAndRemoveAnnotationComments :: ApiAnns -> RealSrcSpan -> ([RealLocated AnnotationComment], ApiAnns)

- ApiAnnotation: getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]

+ ApiAnnotation: getAnnotation :: ApiAnns -> RealSrcSpan -> AnnKeywordId -> [RealSrcSpan]

- ApiAnnotation: getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]

+ ApiAnnotation: getAnnotationComments :: ApiAnns -> RealSrcSpan -> [RealLocated AnnotationComment]

- ApiAnnotation: type ApiAnnKey = (SrcSpan, AnnKeywordId)

+ ApiAnnotation: type ApiAnnKey = (RealSrcSpan, AnnKeywordId)

- Demand: DmdType :: DmdEnv -> [Demand] -> DmdResult -> DmdType

+ Demand: DmdType :: DmdEnv -> [Demand] -> Divergence -> DmdType

- Demand: mkClosedStrictSig :: [Demand] -> DmdResult -> StrictSig

+ Demand: mkClosedStrictSig :: [Demand] -> Divergence -> StrictSig

- Demand: mkDmdType :: DmdEnv -> [Demand] -> DmdResult -> DmdType

+ Demand: mkDmdType :: DmdEnv -> [Demand] -> Divergence -> DmdType

- Demand: splitStrictSig :: StrictSig -> ([Demand], DmdResult)

+ Demand: splitStrictSig :: StrictSig -> ([Demand], Divergence)

- Demand: type BothDmdArg = (DmdEnv, Termination ())

+ Demand: type BothDmdArg = (DmdEnv, Divergence)

- ErrUtils: formatErrDoc :: DynFlags -> ErrDoc -> SDoc

+ ErrUtils: formatErrDoc :: SDocContext -> ErrDoc -> SDoc

- FV: type FV = InterestingVarFun -> VarSet -> ([Var], VarSet) -> ([Var], VarSet)

+ FV: type FV = InterestingVarFun -> VarSet -> VarAcc -> VarAcc

- GHC.Cmm: type RawCmmDecl = GenCmmDecl CmmStatics (LabelMap CmmStatics) CmmGraph

+ GHC.Cmm: type RawCmmDecl = GenCmmDecl RawCmmStatics (LabelMap RawCmmStatics) CmmGraph

- GHC.Cmm: type RawCmmGroup = GenCmmGroup CmmStatics (LabelMap CmmStatics) CmmGraph

+ GHC.Cmm: type RawCmmGroup = GenCmmGroup RawCmmStatics (LabelMap RawCmmStatics) CmmGraph

- GHC.Cmm.Dataflow.Graph: data Graph' block (n :: Extensibility -> Extensibility -> *) e x

+ GHC.Cmm.Dataflow.Graph: data Graph' block (n :: Extensibility -> Extensibility -> Type) e x

- GHC.Hs.Binds: FunBind :: XFunBind idL idR -> Located (IdP idL) -> MatchGroup idR (LHsExpr idR) -> HsWrapper -> [Tickish Id] -> HsBindLR idL idR

+ GHC.Hs.Binds: FunBind :: XFunBind idL idR -> Located (IdP idL) -> MatchGroup idR (LHsExpr idR) -> [Tickish Id] -> HsBindLR idL idR

- GHC.Hs.Binds: ppr_monobind :: (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc

+ GHC.Hs.Binds: ppr_monobind :: forall idL idR. (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc

- GHC.Hs.Decls: tcdName :: TyClDecl pass -> IdP pass

+ GHC.Hs.Decls: tcdName :: TyClDecl (GhcPass p) -> IdP (GhcPass p)

- GHC.Hs.Decls: tyClDeclLName :: TyClDecl pass -> Located (IdP pass)

+ GHC.Hs.Decls: tyClDeclLName :: TyClDecl (GhcPass p) -> Located (IdP (GhcPass p))

- GHC.Hs.Expr: ArrowExpr :: HsStmtContext id

+ GHC.Hs.Expr: ArrowExpr :: HsStmtContext p

- GHC.Hs.Expr: CaseAlt :: HsMatchContext id

+ GHC.Hs.Expr: CaseAlt :: HsMatchContext p

- GHC.Hs.Expr: DoExpr :: HsStmtContext id

+ GHC.Hs.Expr: DoExpr :: HsStmtContext p

- GHC.Hs.Expr: FunRhs :: Located id -> LexicalFixity -> SrcStrictness -> HsMatchContext id

+ GHC.Hs.Expr: FunRhs :: LIdP p -> LexicalFixity -> SrcStrictness -> HsMatchContext p

- GHC.Hs.Expr: GhciStmtCtxt :: HsStmtContext id

+ GHC.Hs.Expr: GhciStmtCtxt :: HsStmtContext p

- GHC.Hs.Expr: HsCmdIf :: XCmdIf id -> Maybe (SyntaxExpr id) -> LHsExpr id -> LHsCmd id -> LHsCmd id -> HsCmd id

+ GHC.Hs.Expr: HsCmdIf :: XCmdIf id -> SyntaxExpr id -> LHsExpr id -> LHsCmd id -> LHsCmd id -> HsCmd id

- GHC.Hs.Expr: HsDo :: XDo p -> HsStmtContext Name -> Located [ExprLStmt p] -> HsExpr p

+ GHC.Hs.Expr: HsDo :: XDo p -> HsStmtContext GhcRn -> Located [ExprLStmt p] -> HsExpr p

- GHC.Hs.Expr: HsIf :: XIf p -> Maybe (SyntaxExpr p) -> LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p

+ GHC.Hs.Expr: HsIf :: XIf p -> SyntaxExpr p -> LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p

- GHC.Hs.Expr: HsSplicedT :: DelayedSplice -> HsSplice id

+ GHC.Hs.Expr: HsSplicedT :: DelayedSplice -> HsSplicedT

- GHC.Hs.Expr: HsWrap :: XWrap p -> HsWrapper -> HsExpr p -> HsExpr p

+ GHC.Hs.Expr: HsWrap :: HsWrapper -> hs_syn GhcTc -> HsWrap hs_syn

- GHC.Hs.Expr: IfAlt :: HsMatchContext id

+ GHC.Hs.Expr: IfAlt :: HsMatchContext p

- GHC.Hs.Expr: LambdaExpr :: HsMatchContext id

+ GHC.Hs.Expr: LambdaExpr :: HsMatchContext p

- GHC.Hs.Expr: ListComp :: HsStmtContext id

+ GHC.Hs.Expr: ListComp :: HsStmtContext p

- GHC.Hs.Expr: MDoExpr :: HsStmtContext id

+ GHC.Hs.Expr: MDoExpr :: HsStmtContext p

- GHC.Hs.Expr: Match :: XCMatch p body -> HsMatchContext (NameOrRdrName (IdP p)) -> [LPat p] -> GRHSs p body -> Match p body

+ GHC.Hs.Expr: Match :: XCMatch p body -> HsMatchContext (NoGhcTc p) -> [LPat p] -> GRHSs p body -> Match p body

- GHC.Hs.Expr: MonadComp :: HsStmtContext id

+ GHC.Hs.Expr: MonadComp :: HsStmtContext p

- GHC.Hs.Expr: ParStmtCtxt :: HsStmtContext id -> HsStmtContext id

+ GHC.Hs.Expr: ParStmtCtxt :: HsStmtContext p -> HsStmtContext p

- GHC.Hs.Expr: PatBindGuards :: HsMatchContext id

+ GHC.Hs.Expr: PatBindGuards :: HsMatchContext p

- GHC.Hs.Expr: PatBindRhs :: HsMatchContext id

+ GHC.Hs.Expr: PatBindRhs :: HsMatchContext p

- GHC.Hs.Expr: PatGuard :: HsMatchContext id -> HsStmtContext id

+ GHC.Hs.Expr: PatGuard :: HsMatchContext p -> HsStmtContext p

- GHC.Hs.Expr: PatSyn :: HsMatchContext id

+ GHC.Hs.Expr: PatSyn :: HsMatchContext p

- GHC.Hs.Expr: ProcExpr :: HsMatchContext id

+ GHC.Hs.Expr: ProcExpr :: HsMatchContext p

- GHC.Hs.Expr: RecUpd :: HsMatchContext id

+ GHC.Hs.Expr: RecUpd :: HsMatchContext p

- GHC.Hs.Expr: StmtCtxt :: HsStmtContext id -> HsMatchContext id

+ GHC.Hs.Expr: StmtCtxt :: HsStmtContext p -> HsMatchContext p

- GHC.Hs.Expr: ThPatQuote :: HsMatchContext id

+ GHC.Hs.Expr: ThPatQuote :: HsMatchContext p

- GHC.Hs.Expr: ThPatSplice :: HsMatchContext id

+ GHC.Hs.Expr: ThPatSplice :: HsMatchContext p

- GHC.Hs.Expr: TransStmtCtxt :: HsStmtContext id -> HsStmtContext id

+ GHC.Hs.Expr: TransStmtCtxt :: HsStmtContext p -> HsStmtContext p

- GHC.Hs.Expr: [m_ctxt] :: Match p body -> HsMatchContext (NameOrRdrName (IdP p))

+ GHC.Hs.Expr: [m_ctxt] :: Match p body -> HsMatchContext (NoGhcTc p)

- GHC.Hs.Expr: [mc_fixity] :: HsMatchContext id -> LexicalFixity

+ GHC.Hs.Expr: [mc_fixity] :: HsMatchContext p -> LexicalFixity

- GHC.Hs.Expr: [mc_fun] :: HsMatchContext id -> Located id

+ GHC.Hs.Expr: [mc_fun] :: HsMatchContext p -> LIdP p

- GHC.Hs.Expr: [mc_strictness] :: HsMatchContext id -> SrcStrictness

+ GHC.Hs.Expr: [mc_strictness] :: HsMatchContext p -> SrcStrictness

- GHC.Hs.Expr: [syn_arg_wraps] :: SyntaxExpr p -> [HsWrapper]

+ GHC.Hs.Expr: [syn_arg_wraps] :: SyntaxExprTc -> [HsWrapper]

- GHC.Hs.Expr: [syn_expr] :: SyntaxExpr p -> HsExpr p

+ GHC.Hs.Expr: [syn_expr] :: SyntaxExprTc -> HsExpr GhcTc

- GHC.Hs.Expr: [syn_res_wrap] :: SyntaxExpr p -> HsWrapper

+ GHC.Hs.Expr: [syn_res_wrap] :: SyntaxExprTc -> HsWrapper

- GHC.Hs.Expr: data HsMatchContext id

+ GHC.Hs.Expr: data HsMatchContext p

- GHC.Hs.Expr: data HsStmtContext id

+ GHC.Hs.Expr: data HsStmtContext p

- GHC.Hs.Expr: hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool

+ GHC.Hs.Expr: hsExprNeedsParens :: forall p. IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool

- GHC.Hs.Expr: isAtomicHsExpr :: HsExpr id -> Bool

+ GHC.Hs.Expr: isAtomicHsExpr :: forall p. IsPass p => HsExpr (GhcPass p) -> Bool

- GHC.Hs.Expr: isPatSynCtxt :: HsMatchContext id -> Bool

+ GHC.Hs.Expr: isPatSynCtxt :: HsMatchContext p -> Bool

- GHC.Hs.Expr: matchContextErrString :: Outputable id => HsMatchContext id -> SDoc

+ GHC.Hs.Expr: matchContextErrString :: OutputableBndrId p => HsMatchContext (GhcPass p) -> SDoc

- GHC.Hs.Expr: matchSeparator :: HsMatchContext id -> SDoc

+ GHC.Hs.Expr: matchSeparator :: HsMatchContext p -> SDoc

- GHC.Hs.Expr: mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn

+ GHC.Hs.Expr: mkRnSyntaxExpr :: Name -> SyntaxExprRn

- GHC.Hs.Expr: mkSyntaxExpr :: HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p)

+ GHC.Hs.Expr: mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn

- GHC.Hs.Expr: noSyntaxExpr :: SyntaxExpr (GhcPass p)

+ GHC.Hs.Expr: noSyntaxExpr :: forall p. IsPass p => SyntaxExpr (GhcPass p)

- GHC.Hs.Expr: parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)

+ GHC.Hs.Expr: parenthesizeHsExpr :: IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)

- GHC.Hs.Expr: pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc

+ GHC.Hs.Expr: pp_rhs :: Outputable body => HsMatchContext passL -> body -> SDoc

- GHC.Hs.Expr: pprAStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc

+ GHC.Hs.Expr: pprAStmtContext :: Outputable (IdP id) => HsStmtContext id -> SDoc

- GHC.Hs.Expr: pprGRHS :: (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc

+ GHC.Hs.Expr: pprGRHS :: (OutputableBndrId idR, Outputable body) => HsMatchContext passL -> GRHS (GhcPass idR) body -> SDoc

- GHC.Hs.Expr: pprGRHSs :: (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc

+ GHC.Hs.Expr: pprGRHSs :: (OutputableBndrId idR, Outputable body) => HsMatchContext passL -> GRHSs (GhcPass idR) body -> SDoc

- GHC.Hs.Expr: pprMatchContext :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc

+ GHC.Hs.Expr: pprMatchContext :: Outputable (IdP p) => HsMatchContext p -> SDoc

- GHC.Hs.Expr: pprMatchContextNoun :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc

+ GHC.Hs.Expr: pprMatchContextNoun :: Outputable (IdP id) => HsMatchContext id -> SDoc

- GHC.Hs.Expr: pprMatchInCtxt :: (OutputableBndrId idR, Outputable (NameOrRdrName (NameOrRdrName (IdP (GhcPass idR)))), Outputable body) => Match (GhcPass idR) body -> SDoc

+ GHC.Hs.Expr: pprMatchInCtxt :: (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc

- GHC.Hs.Expr: pprSplice :: OutputableBndrId p => HsSplice (GhcPass p) -> SDoc

+ GHC.Hs.Expr: pprSplice :: forall p. OutputableBndrId p => HsSplice (GhcPass p) -> SDoc

- GHC.Hs.Expr: pprStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc

+ GHC.Hs.Expr: pprStmtContext :: Outputable (IdP id) => HsStmtContext id -> SDoc

- GHC.Hs.Expr: pprStmtInCtxt :: (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext (IdP (GhcPass idL)) -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc

+ GHC.Hs.Expr: pprStmtInCtxt :: (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext (GhcPass idL) -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc

- GHC.Hs.Expr: ppr_infix_expr :: OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc

+ GHC.Hs.Expr: ppr_infix_expr :: forall p. OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc

- GHC.Hs.Extension: type OutputableBndrId pass = (OutputableBndr (NameOrRdrName (IdP (GhcPass pass))), OutputableBndr (IdP (GhcPass pass)), OutputableBndr (NameOrRdrName (IdP (NoGhcTc (GhcPass pass)))), OutputableBndr (IdP (NoGhcTc (GhcPass pass))), NoGhcTc (GhcPass pass) ~ NoGhcTc (NoGhcTc (GhcPass pass)), OutputableX (GhcPass pass), OutputableX (NoGhcTc (GhcPass pass)))

+ GHC.Hs.Extension: type OutputableBndrId pass = (OutputableBndr (IdGhcP pass), OutputableBndr (IdGhcP (NoGhcTcPass pass)), IsPass pass)

- GHC.Hs.Lit: convertLit :: ConvertIdX a b => HsLit a -> HsLit b

+ GHC.Hs.Lit: convertLit :: HsLit (GhcPass p1) -> HsLit (GhcPass p2)

- GHC.Hs.Utils: mkBindStmt :: XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExtField => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR)))

+ GHC.Hs.Utils: mkBindStmt :: IsPass idR => XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExtField => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR)))

- GHC.Hs.Utils: mkHsCmdIf :: LHsExpr (GhcPass p) -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) -> HsCmd (GhcPass p)

+ GHC.Hs.Utils: mkHsCmdIf :: LHsExpr GhcPs -> LHsCmd GhcPs -> LHsCmd GhcPs -> HsCmd GhcPs

- GHC.Hs.Utils: mkHsCmdWrap :: HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p)

+ GHC.Hs.Utils: mkHsCmdWrap :: HsWrapper -> HsCmd GhcTc -> HsCmd GhcTc

- GHC.Hs.Utils: mkHsComp :: HsStmtContext Name -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs

+ GHC.Hs.Utils: mkHsComp :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs

- GHC.Hs.Utils: mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs

+ GHC.Hs.Utils: mkHsDo :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> HsExpr GhcPs

- GHC.Hs.Utils: mkHsIf :: LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> HsExpr (GhcPass p)

+ GHC.Hs.Utils: mkHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs

- GHC.Hs.Utils: mkHsWrap :: HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)

+ GHC.Hs.Utils: mkHsWrap :: HsWrapper -> HsExpr GhcTc -> HsExpr GhcTc

- GHC.Hs.Utils: mkHsWrapCo :: TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)

+ GHC.Hs.Utils: mkHsWrapCo :: TcCoercionN -> HsExpr GhcTc -> HsExpr GhcTc

- GHC.Hs.Utils: mkHsWrapCoR :: TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)

+ GHC.Hs.Utils: mkHsWrapCoR :: TcCoercionR -> HsExpr GhcTc -> HsExpr GhcTc

- GHC.Hs.Utils: mkHsWrapPat :: HsWrapper -> Pat (GhcPass id) -> Type -> Pat (GhcPass id)

+ GHC.Hs.Utils: mkHsWrapPat :: HsWrapper -> Pat GhcTc -> Type -> Pat GhcTc

- GHC.Hs.Utils: mkHsWrapPatCo :: TcCoercionN -> Pat (GhcPass id) -> Type -> Pat (GhcPass id)

+ GHC.Hs.Utils: mkHsWrapPatCo :: TcCoercionN -> Pat GhcTc -> Type -> Pat GhcTc

- GHC.Hs.Utils: mkLHsCmdWrap :: HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p)

+ GHC.Hs.Utils: mkLHsCmdWrap :: HsWrapper -> LHsCmd GhcTc -> LHsCmd GhcTc

- GHC.Hs.Utils: mkLHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: mkLHsPar :: IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

- GHC.Hs.Utils: mkLHsWrap :: HsWrapper -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: mkLHsWrap :: HsWrapper -> LHsExpr GhcTc -> LHsExpr GhcTc

- GHC.Hs.Utils: mkLHsWrapCo :: TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: mkLHsWrapCo :: TcCoercionN -> LHsExpr GhcTc -> LHsExpr GhcTc

- GHC.Hs.Utils: mkLastStmt :: Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR)))

+ GHC.Hs.Utils: mkLastStmt :: IsPass idR => Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR)))

- GHC.Hs.Utils: mkMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> Located (HsLocalBinds (GhcPass p)) -> LMatch (GhcPass p) (LHsExpr (GhcPass p))

+ GHC.Hs.Utils: mkMatch :: HsMatchContext (NoGhcTc (GhcPass p)) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> Located (HsLocalBinds (GhcPass p)) -> LMatch (GhcPass p) (LHsExpr (GhcPass p))

- GHC.Hs.Utils: mkPrefixFunRhs :: Located id -> HsMatchContext id

+ GHC.Hs.Utils: mkPrefixFunRhs :: LIdP p -> HsMatchContext p

- GHC.Hs.Utils: mkSimpleMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p)))

+ GHC.Hs.Utils: mkSimpleMatch :: HsMatchContext (NoGhcTc (GhcPass p)) -> [LPat (GhcPass p)] -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p)))

- GHC.Hs.Utils: nlHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: nlHsApp :: IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

- GHC.Hs.Utils: nlHsApps :: IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: nlHsApps :: IsPass id => IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)

- GHC.Hs.Utils: nlHsDo :: HsStmtContext Name -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs

+ GHC.Hs.Utils: nlHsDo :: HsStmtContext GhcRn -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs

- GHC.Hs.Utils: nlHsIf :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: nlHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs

- GHC.Hs.Utils: nlHsSyntaxApps :: SyntaxExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: nlHsSyntaxApps :: SyntaxExprTc -> [LHsExpr GhcTc] -> LHsExpr GhcTc

- GHC.Hs.Utils: nlHsTyApp :: IdP (GhcPass id) -> [Type] -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: nlHsTyApp :: Id -> [Type] -> LHsExpr GhcTc

- GHC.Hs.Utils: nlHsTyApps :: IdP (GhcPass id) -> [Type] -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)

+ GHC.Hs.Utils: nlHsTyApps :: Id -> [Type] -> [LHsExpr GhcTc] -> LHsExpr GhcTc

- GHC.Iface.Type: stripIfaceInvisVars :: DynFlags -> [IfaceTyConBinder] -> [IfaceTyConBinder]

+ GHC.Iface.Type: stripIfaceInvisVars :: PrintExplicitKinds -> [IfaceTyConBinder] -> [IfaceTyConBinder]

- GHC.Iface.Type: stripInvisArgs :: DynFlags -> IfaceAppArgs -> IfaceAppArgs

+ GHC.Iface.Type: stripInvisArgs :: PrintExplicitKinds -> IfaceAppArgs -> IfaceAppArgs

- GHC.Iface.Type: suppressIfaceInvisibles :: DynFlags -> [IfaceTyConBinder] -> [a] -> [a]

+ GHC.Iface.Type: suppressIfaceInvisibles :: PrintExplicitKinds -> [IfaceTyConBinder] -> [a] -> [a]

- Id: infixl 1 `setIdStrictness`

+ Id: infixl 1 `setIdCprInfo`

- Language.Haskell.TH.Syntax: dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp

+ Language.Haskell.TH.Syntax: dataToExpQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp

- Language.Haskell.TH.Syntax: dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat

+ Language.Haskell.TH.Syntax: dataToPatQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat

- Language.Haskell.TH.Syntax: dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q

+ Language.Haskell.TH.Syntax: dataToQa :: forall m a k q. (Quote m, Data a) => (Name -> k) -> (Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. Data b => b -> Maybe (m q)) -> a -> m q

- Language.Haskell.TH.Syntax: liftData :: Data a => a -> Q Exp

+ Language.Haskell.TH.Syntax: liftData :: (Quote m, Data a) => a -> m Exp

- Lexer: ITqQuasiQuote :: (FastString, FastString, FastString, RealSrcSpan) -> Token

+ Lexer: ITqQuasiQuote :: (FastString, FastString, FastString, PsSpan) -> Token

- Lexer: ITquasiQuote :: (FastString, FastString, RealSrcSpan) -> Token

+ Lexer: ITquasiQuote :: (FastString, FastString, PsSpan) -> Token

- 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 -> PsSpan -> !Int -> PsLoc -> [LayoutContext] -> [Int] -> [FastString] -> [PsLocated Token] -> Maybe (PsLocated Token) -> PsSpan -> [ALRContext] -> Maybe ALRLayout -> Bool -> [(ApiAnnKey, [RealSrcSpan])] -> Maybe RealSrcSpan -> [RealLocated AnnotationComment] -> [(RealSrcSpan, [RealLocated AnnotationComment])] -> PState

- Lexer: [alr_last_loc] :: PState -> RealSrcSpan

+ Lexer: [alr_last_loc] :: PState -> PsSpan

- Lexer: [alr_next_token] :: PState -> Maybe (RealLocated Token)

+ Lexer: [alr_next_token] :: PState -> Maybe (PsLocated Token)

- Lexer: [alr_pending_implicit_tokens] :: PState -> [RealLocated Token]

+ Lexer: [alr_pending_implicit_tokens] :: PState -> [PsLocated Token]

- Lexer: [annotations] :: PState -> [(ApiAnnKey, [SrcSpan])]

+ Lexer: [annotations] :: PState -> [(ApiAnnKey, [RealSrcSpan])]

- Lexer: [annotations_comments] :: PState -> [(SrcSpan, [Located AnnotationComment])]

+ Lexer: [annotations_comments] :: PState -> [(RealSrcSpan, [RealLocated AnnotationComment])]

- Lexer: [comment_q] :: PState -> [Located AnnotationComment]

+ Lexer: [comment_q] :: PState -> [RealLocated AnnotationComment]

- Lexer: [last_loc] :: PState -> RealSrcSpan

+ Lexer: [last_loc] :: PState -> PsSpan

- Lexer: [loc] :: PState -> RealSrcLoc

+ Lexer: [loc] :: PState -> PsLoc

- Lexer: allocateComments :: SrcSpan -> [Located AnnotationComment] -> ([Located AnnotationComment], [(SrcSpan, [Located AnnotationComment])])

+ Lexer: allocateComments :: RealSrcSpan -> [RealLocated AnnotationComment] -> ([RealLocated AnnotationComment], [(RealSrcSpan, [RealLocated AnnotationComment])])

- Lexer: commentToAnnotation :: Located Token -> Located AnnotationComment

+ Lexer: commentToAnnotation :: RealLocated Token -> RealLocated AnnotationComment

- Lexer: setLastToken :: RealSrcSpan -> Int -> P ()

+ Lexer: setLastToken :: PsSpan -> Int -> P ()

- NameEnv: depAnal :: (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node]

+ NameEnv: depAnal :: forall node. (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node]

- Outputable: isEmpty :: DynFlags -> SDoc -> Bool

+ Outputable: isEmpty :: SDocContext -> SDoc -> Bool

- Outputable: renderWithStyle :: DynFlags -> SDoc -> PprStyle -> String

+ Outputable: renderWithStyle :: SDocContext -> SDoc -> String

- Predicate: ForAllPred :: [TyCoVarBinder] -> [PredType] -> PredType -> Pred

+ Predicate: ForAllPred :: [TyVar] -> [PredType] -> PredType -> Pred

- RdrHsSyn: checkMonadComp :: PV (HsStmtContext Name)

+ RdrHsSyn: checkMonadComp :: PV (HsStmtContext GhcRn)

- RdrHsSyn: mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs

+ RdrHsSyn: mkHsDo :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> HsExpr GhcPs

- SrcLoc: RealSrcLoc :: {-# UNPACK #-} !RealSrcLoc -> SrcLoc

+ SrcLoc: RealSrcLoc :: !RealSrcLoc -> !Maybe BufPos -> SrcLoc

- SrcLoc: RealSrcSpan :: !RealSrcSpan -> SrcSpan

+ SrcLoc: RealSrcSpan :: !RealSrcSpan -> !Maybe BufSpan -> SrcSpan

- TcOrigin: PatSkol :: ConLike -> HsMatchContext Name -> SkolemInfo

+ TcOrigin: PatSkol :: ConLike -> HsMatchContext GhcRn -> SkolemInfo

- TcRnTypes: DsLclEnv :: DsMetaEnv -> RealSrcSpan -> Delta -> DsLclEnv

+ TcRnTypes: DsLclEnv :: DsMetaEnv -> RealSrcSpan -> Deltas -> DsLclEnv

- TcType: closeOverKinds :: TyVarSet -> TyVarSet

+ TcType: closeOverKinds :: TyCoVarSet -> TyCoVarSet

- TcType: exactTyCoVarsOfTypes :: [Type] -> TyVarSet

+ TcType: exactTyCoVarsOfTypes :: [Type] -> TyCoVarSet

- TrieMap: type family Key m :: *;

+ TrieMap: type family Key m :: Type;

- TyCoFVs: coVarsOfTypes :: [Type] -> TyCoVarSet

+ TyCoFVs: coVarsOfTypes :: [Type] -> CoVarSet

- Type: closeOverKinds :: TyVarSet -> TyVarSet

+ Type: closeOverKinds :: TyCoVarSet -> TyCoVarSet

- Type: coVarsOfTypes :: [Type] -> TyCoVarSet

+ Type: coVarsOfTypes :: [Type] -> CoVarSet

Files

compiler/GHC/ByteCode/Types.hs +182/−0
compiler/GHC/Cmm.hs +28/−12
compiler/GHC/Cmm/CLabel.hs +11/−5
compiler/GHC/Cmm/Dataflow/Collections.hs +3/−0
compiler/GHC/Cmm/Dataflow/Graph.hs +4/−2
compiler/GHC/Cmm/Dataflow/Label.hs +3/−0
compiler/GHC/Cmm/Expr.hs +1/−1
compiler/GHC/Cmm/MachOp.hs +1/−1
compiler/GHC/Cmm/Node.hs +3/−3
compiler/GHC/Cmm/Switch.hs +1/−1
compiler/GHC/Cmm/Type.hs +1/−1
compiler/GHC/Core.hs +2346/−0
compiler/GHC/Core/Arity.hs +1211/−0
compiler/GHC/Core/FVs.hs +777/−0
compiler/GHC/Core/Make.hs +940/−0
compiler/GHC/Core/Map.hs +803/−0
compiler/GHC/Core/Op/Tidy.hs +286/−0
compiler/GHC/Core/Ppr.hs +657/−0
compiler/GHC/Core/Rules.hs +1254/−0
compiler/GHC/Core/Seq.hs +115/−0
compiler/GHC/Core/SimpleOpt.hs +1475/−0
compiler/GHC/Core/Stats.hs +137/−0
compiler/GHC/Core/Subst.hs +758/−0
compiler/GHC/Core/Unfold.hs +1642/−0
compiler/GHC/Core/Unfold.hs-boot +16/−0
compiler/GHC/Core/Utils.hs +2567/−0
compiler/GHC/CoreToIface.hs +9/−7
compiler/GHC/Driver/Backpack/Syntax.hs +83/−0
compiler/GHC/Driver/CmdLine.hs +339/−0
compiler/GHC/Driver/Hooks.hs +121/−0
compiler/GHC/Driver/Hooks.hs-boot +7/−0
compiler/GHC/Driver/Monad.hs +204/−0
compiler/GHC/Driver/Packages.hs +2215/−0
compiler/GHC/Driver/Packages.hs-boot +12/−0
compiler/GHC/Driver/Phases.hs +370/−0
compiler/GHC/Driver/Pipeline/Monad.hs +122/−0
compiler/GHC/Driver/Plugins.hs +264/−0
compiler/GHC/Driver/Plugins.hs-boot +10/−0
compiler/GHC/Driver/Session.hs +5939/−0
compiler/GHC/Driver/Session.hs-boot +17/−0
compiler/GHC/Driver/Types.hs +3284/−0
compiler/GHC/Hs.hs +2/−4
compiler/GHC/Hs/Binds.hs +50/−60
compiler/GHC/Hs/Decls.hs +32/−12
compiler/GHC/Hs/Expr.hs +206/−133
compiler/GHC/Hs/Expr.hs-boot +9/−9
compiler/GHC/Hs/Extension.hs +140/−548
compiler/GHC/Hs/ImpExp.hs +2/−2
compiler/GHC/Hs/Instances.hs +7/−9
compiler/GHC/Hs/Lit.hs +19/−20
compiler/GHC/Hs/Pat.hs +50/−27
compiler/GHC/Hs/Pat.hs-boot +4/−3
compiler/GHC/Hs/PlaceHolder.hs +0/−70
compiler/GHC/Hs/Types.hs +2/−27
compiler/GHC/Hs/Utils.hs +63/−63
compiler/GHC/HsToCore/PmCheck/Types.hs +23/−7
compiler/GHC/HsToCore/PmCheck/Types.hs-boot +4/−2
compiler/GHC/Iface/Syntax.hs +36/−54
compiler/GHC/Iface/Type.hs +63/−72
compiler/GHC/Platform/Reg.hs +241/−0
compiler/GHC/Platform/Reg/Class.hs +32/−0
compiler/GHC/Platform/Regs.hs +1/−1
compiler/GHC/Runtime/Eval/Types.hs +89/−0
compiler/GHC/Runtime/Heap/Layout.hs +563/−0
compiler/GHC/Runtime/Interpreter/Types.hs +63/−0
compiler/GHC/Runtime/Layout.hs +0/−563
compiler/GHC/Runtime/Linker/Types.hs +112/−0
compiler/GHC/Stg/Syntax.hs +35/−93
compiler/backpack/BkpSyn.hs +0/−83
compiler/basicTypes/BasicTypes.hs +9/−6
compiler/basicTypes/Cpr.hs +163/−0
compiler/basicTypes/DataCon.hs +8/−40
compiler/basicTypes/Demand.hs +78/−177
compiler/basicTypes/Id.hs +18/−6
compiler/basicTypes/IdInfo.hs +14/−4
compiler/basicTypes/Literal.hs +4/−4
compiler/basicTypes/MkId.hs +42/−71
compiler/basicTypes/Module.hs +3/−3
compiler/basicTypes/Name.hs +10/−18
compiler/basicTypes/NameCache.hs +2/−2
compiler/basicTypes/NameEnv.hs +9/−3
compiler/basicTypes/OccName.hs +4/−5
compiler/basicTypes/PatSyn.hs +1/−1
compiler/basicTypes/Predicate.hs +2/−2
compiler/basicTypes/RdrName.hs +11/−30
compiler/basicTypes/SrcLoc.hs +168/−40
compiler/basicTypes/Unique.hs +0/−6
compiler/basicTypes/Var.hs +2/−3
compiler/basicTypes/VarSet.hs +4/−0
compiler/coreSyn/CoreArity.hs +0/−1210
compiler/coreSyn/CoreFVs.hs +0/−778
compiler/coreSyn/CoreMap.hs +0/−803
compiler/coreSyn/CoreOpt.hs +0/−1475
compiler/coreSyn/CoreSeq.hs +0/−113
compiler/coreSyn/CoreStats.hs +0/−137
compiler/coreSyn/CoreSubst.hs +0/−758
compiler/coreSyn/CoreSyn.hs +0/−2349
compiler/coreSyn/CoreTidy.hs +0/−286
compiler/coreSyn/CoreUnfold.hs +0/−1618
compiler/coreSyn/CoreUnfold.hs-boot +0/−14
compiler/coreSyn/CoreUtils.hs +0/−2675
compiler/coreSyn/MkCore.hs +0/−937
compiler/coreSyn/PprCore.hs +0/−620
compiler/ghci/ByteCodeTypes.hs +0/−182
compiler/ghci/LinkerTypes.hs +0/−112
compiler/main/CmdLineParser.hs +0/−339
compiler/main/DriverPhases.hs +0/−371
compiler/main/DynFlags.hs +0/−5920
compiler/main/DynFlags.hs-boot +0/−19
compiler/main/ErrUtils.hs +27/−28
compiler/main/ErrUtils.hs-boot +1/−1
compiler/main/FileCleanup.hs +2/−2
compiler/main/GhcMonad.hs +0/−204
compiler/main/HeaderInfo.hs +4/−4
compiler/main/Hooks.hs +0/−118
compiler/main/Hooks.hs-boot +0/−7
compiler/main/HscTypes.hs +0/−3268
compiler/main/InteractiveEvalTypes.hs +0/−89
compiler/main/Packages.hs +0/−2215
compiler/main/Packages.hs-boot +0/−12
compiler/main/PipelineMonad.hs +0/−122
compiler/main/Plugins.hs +0/−264
compiler/main/Plugins.hs-boot +0/−10
compiler/nativeGen/Reg.hs +0/−241
compiler/nativeGen/RegClass.hs +0/−32
compiler/parser/ApiAnnotation.hs +53/−39
compiler/parser/RdrHsSyn.hs +12/−12
compiler/prelude/PrelNames.hs +35/−7
compiler/prelude/PrelRules.hs +70/−40
compiler/prelude/PrimOp.hs +4/−4
compiler/prelude/TysPrim.hs +4/−2
compiler/prelude/TysWiredIn.hs +13/−13
compiler/prelude/TysWiredIn.hs-boot +2/−0
compiler/simplCore/CoreMonad.hs +8/−6
compiler/simplCore/OccurAnal.hs +13/−8
compiler/specialise/Rules.hs +0/−1254
compiler/typecheck/Constraint.hs +13/−7
compiler/typecheck/TcEvidence.hs +9/−11
compiler/typecheck/TcOrigin.hs +13/−20
compiler/typecheck/TcRnTypes.hs +15/−17
compiler/typecheck/TcType.hs +39/−3
compiler/types/CoAxiom.hs +2/−2
compiler/types/Coercion.hs +5/−17
compiler/types/Coercion.hs-boot +0/−1
compiler/types/FamInstEnv.hs +2/−2
compiler/types/InstEnv.hs +1/−1
compiler/types/OptCoercion.hs +2/−4
compiler/types/TyCoFVs.hs +386/−263
compiler/types/TyCoPpr.hs +5/−7
compiler/types/TyCoRep.hs +171/−13
compiler/types/TyCoSubst.hs +18/−18
compiler/types/TyCoTidy.hs +1/−2
compiler/types/TyCon.hs +10/−9
compiler/types/Type.hs +59/−41
compiler/utils/Binary.hs +17/−2
compiler/utils/Digraph.hs +1/−1
compiler/utils/FV.hs +16/−17
compiler/utils/IOEnv.hs +1/−1
compiler/utils/ListSetOps.hs +7/−7
compiler/utils/Outputable.hs +121/−75
compiler/utils/Outputable.hs-boot +2/−0
compiler/utils/TrieMap.hs +4/−3
compiler/utils/Util.hs +10/−14
ghc-lib-parser.cabal +33/−37
ghc-lib/stage0/compiler/build/Lexer.hs +141/−135
ghc-lib/stage0/compiler/build/Parser.hs +66/−67
ghc-lib/stage0/compiler/build/primop-data-decl.hs-incl +3/−0
ghc-lib/stage0/compiler/build/primop-has-side-effects.hs-incl +3/−0
ghc-lib/stage0/compiler/build/primop-list.hs-incl +3/−0
ghc-lib/stage0/compiler/build/primop-out-of-line.hs-incl +3/−0
ghc-lib/stage0/compiler/build/primop-primop-info.hs-incl +3/−0
ghc-lib/stage0/compiler/build/primop-strictness.hs-incl +19/−16
ghc-lib/stage0/compiler/build/primop-tag.hs-incl +1209/−1206
ghc-lib/stage0/lib/ghcversion.h +1/−1
ghc-lib/stage0/lib/llvm-targets +1/−0
ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs +4/−4
includes/CodeGen.Platform.hs +1/−1
libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs +1/−1
libraries/ghc-heap/GHC/Exts/Heap.hs +2/−2
libraries/ghci/GHCi/BreakArray.hs +1/−1
libraries/template-haskell/Language/Haskell/TH.hs +1/−0
libraries/template-haskell/Language/Haskell/TH/LanguageExtensions.hs +1/−0
libraries/template-haskell/Language/Haskell/TH/Lib.hs +2/−0
libraries/template-haskell/Language/Haskell/TH/Lib/Internal.hs +2/−0
libraries/template-haskell/Language/Haskell/TH/Lib/Map.hs +1/−0
libraries/template-haskell/Language/Haskell/TH/Ppr.hs +1/−0
libraries/template-haskell/Language/Haskell/TH/PprLib.hs +1/−1
libraries/template-haskell/Language/Haskell/TH/Syntax.hs +22/−21

+ compiler/GHC/ByteCode/Types.hs view

@@ -0,0 +1,182 @@+{-# LANGUAGE MagicHash, RecordWildCards, GeneralizedNewtypeDeriving #-}+--+--  (c) The University of Glasgow 2002-2006+--++-- | Bytecode assembler types+module GHC.ByteCode.Types+  ( CompiledByteCode(..), seqCompiledByteCode, FFIInfo(..)+  , UnlinkedBCO(..), BCOPtr(..), BCONPtr(..)+  , ItblEnv, ItblPtr(..)+  , CgBreakInfo(..)+  , ModBreaks (..), BreakIndex, emptyModBreaks+  , CCostCentre+  ) where++import GhcPrelude++import FastString+import Id+import Name+import NameEnv+import Outputable+import PrimOp+import SizedSeq+import Type+import SrcLoc+import GHCi.BreakArray+import GHCi.RemoteTypes+import GHCi.FFI+import Control.DeepSeq++import Foreign+import Data.Array+import Data.Array.Base  ( UArray(..) )+import Data.ByteString (ByteString)+import Data.IntMap (IntMap)+import qualified Data.IntMap as IntMap+import Data.Maybe (catMaybes)+import GHC.Exts.Heap+import GHC.Stack.CCS++-- -----------------------------------------------------------------------------+-- Compiled Byte Code++data CompiledByteCode = CompiledByteCode+  { bc_bcos   :: [UnlinkedBCO]  -- Bunch of interpretable bindings+  , bc_itbls  :: ItblEnv        -- A mapping from DataCons to their itbls+  , bc_ffis   :: [FFIInfo]      -- ffi blocks we allocated+  , bc_strs   :: [RemotePtr ()] -- malloc'd strings+  , bc_breaks :: Maybe ModBreaks -- breakpoint info (Nothing if we're not+                                 -- creating breakpoints, for some reason)+  }+                -- ToDo: we're not tracking strings that we malloc'd+newtype FFIInfo = FFIInfo (RemotePtr C_ffi_cif)+  deriving (Show, NFData)++instance Outputable CompiledByteCode where+  ppr CompiledByteCode{..} = ppr bc_bcos++-- Not a real NFData instance, because ModBreaks contains some things+-- we can't rnf+seqCompiledByteCode :: CompiledByteCode -> ()+seqCompiledByteCode CompiledByteCode{..} =+  rnf bc_bcos `seq`+  rnf (nameEnvElts bc_itbls) `seq`+  rnf bc_ffis `seq`+  rnf bc_strs `seq`+  rnf (fmap seqModBreaks bc_breaks)++type ItblEnv = NameEnv (Name, ItblPtr)+        -- We need the Name in the range so we know which+        -- elements to filter out when unloading a module++newtype ItblPtr = ItblPtr (RemotePtr StgInfoTable)+  deriving (Show, NFData)++data UnlinkedBCO+   = UnlinkedBCO {+        unlinkedBCOName   :: !Name,+        unlinkedBCOArity  :: {-# UNPACK #-} !Int,+        unlinkedBCOInstrs :: !(UArray Int Word16),      -- insns+        unlinkedBCOBitmap :: !(UArray Int Word64),      -- bitmap+        unlinkedBCOLits   :: !(SizedSeq BCONPtr),       -- non-ptrs+        unlinkedBCOPtrs   :: !(SizedSeq BCOPtr)         -- ptrs+   }++instance NFData UnlinkedBCO where+  rnf UnlinkedBCO{..} =+    rnf unlinkedBCOLits `seq`+    rnf unlinkedBCOPtrs++data BCOPtr+  = BCOPtrName   !Name+  | BCOPtrPrimOp !PrimOp+  | BCOPtrBCO    !UnlinkedBCO+  | BCOPtrBreakArray  -- a pointer to this module's BreakArray++instance NFData BCOPtr where+  rnf (BCOPtrBCO bco) = rnf bco+  rnf x = x `seq` ()++data BCONPtr+  = BCONPtrWord  {-# UNPACK #-} !Word+  | BCONPtrLbl   !FastString+  | BCONPtrItbl  !Name+  | BCONPtrStr   !ByteString++instance NFData BCONPtr where+  rnf x = x `seq` ()++-- | Information about a breakpoint that we know at code-generation time+data CgBreakInfo+   = CgBreakInfo+   { cgb_vars   :: [Maybe (Id,Word16)]+   , cgb_resty  :: Type+   }+-- See Note [Syncing breakpoint info] in GHC.Runtime.Eval++-- Not a real NFData instance because we can't rnf Id or Type+seqCgBreakInfo :: CgBreakInfo -> ()+seqCgBreakInfo CgBreakInfo{..} =+  rnf (map snd (catMaybes (cgb_vars))) `seq`+  seqType cgb_resty++instance Outputable UnlinkedBCO where+   ppr (UnlinkedBCO nm _arity _insns _bitmap lits ptrs)+      = sep [text "BCO", ppr nm, text "with",+             ppr (sizeSS lits), text "lits",+             ppr (sizeSS ptrs), text "ptrs" ]++instance Outputable CgBreakInfo where+   ppr info = text "CgBreakInfo" <+>+              parens (ppr (cgb_vars info) <+>+                      ppr (cgb_resty info))++-- -----------------------------------------------------------------------------+-- Breakpoints++-- | Breakpoint index+type BreakIndex = Int++-- | C CostCentre type+data CCostCentre++-- | All the information about the breakpoints for a module+data ModBreaks+   = ModBreaks+   { modBreaks_flags :: ForeignRef BreakArray+        -- ^ The array of flags, one per breakpoint,+        -- indicating which breakpoints are enabled.+   , modBreaks_locs :: !(Array BreakIndex SrcSpan)+        -- ^ An array giving the source span of each breakpoint.+   , modBreaks_vars :: !(Array BreakIndex [OccName])+        -- ^ An array giving the names of the free variables at each breakpoint.+   , modBreaks_decls :: !(Array BreakIndex [String])+        -- ^ An array giving the names of the declarations enclosing each breakpoint.+   , modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))+        -- ^ Array pointing to cost centre for each breakpoint+   , modBreaks_breakInfo :: IntMap CgBreakInfo+        -- ^ info about each breakpoint from the bytecode generator+   }++seqModBreaks :: ModBreaks -> ()+seqModBreaks ModBreaks{..} =+  rnf modBreaks_flags `seq`+  rnf modBreaks_locs `seq`+  rnf modBreaks_vars `seq`+  rnf modBreaks_decls `seq`+  rnf modBreaks_ccs `seq`+  rnf (fmap seqCgBreakInfo modBreaks_breakInfo)++-- | Construct an empty ModBreaks+emptyModBreaks :: ModBreaks+emptyModBreaks = ModBreaks+   { modBreaks_flags = error "ModBreaks.modBreaks_array not initialised"+         -- ToDo: can we avoid this?+   , modBreaks_locs  = array (0,-1) []+   , modBreaks_vars  = array (0,-1) []+   , modBreaks_decls = array (0,-1) []+   , modBreaks_ccs = array (0,-1) []+   , modBreaks_breakInfo = IntMap.empty+   }

compiler/GHC/Cmm.hs view

@@ -3,12 +3,11 @@  module GHC.Cmm (      -- * Cmm top-level datatypes-     CmmProgram, CmmGroup, GenCmmGroup,-     CmmDecl, GenCmmDecl(..),+     CmmProgram, CmmGroup, CmmGroupSRTs, RawCmmGroup, GenCmmGroup,+     CmmDecl, CmmDeclSRTs, GenCmmDecl(..),      CmmGraph, GenCmmGraph(..),-     CmmBlock,-     RawCmmDecl, RawCmmGroup,-     Section(..), SectionType(..), CmmStatics(..), CmmStatic(..),+     CmmBlock, RawCmmDecl,+     Section(..), SectionType(..), CmmStatics(..), RawCmmStatics(..), CmmStatic(..),      isSecConstant,       -- ** Blocks containing lists@@ -32,7 +31,7 @@ import GHC.Cmm.CLabel import GHC.Cmm.BlockId import GHC.Cmm.Node-import GHC.Runtime.Layout+import GHC.Runtime.Heap.Layout import GHC.Cmm.Expr import GHC.Cmm.Dataflow.Block import GHC.Cmm.Dataflow.Collections@@ -56,8 +55,12 @@ type CmmProgram = [CmmGroup]  type GenCmmGroup d h g = [GenCmmDecl d h g]-type CmmGroup = GenCmmGroup CmmStatics CmmTopInfo CmmGraph-type RawCmmGroup = GenCmmGroup CmmStatics (LabelMap CmmStatics) CmmGraph+-- | Cmm group before SRT generation+type CmmGroup     = GenCmmGroup CmmStatics    CmmTopInfo               CmmGraph+-- | Cmm group with SRTs+type CmmGroupSRTs = GenCmmGroup RawCmmStatics CmmTopInfo               CmmGraph+-- | "Raw" cmm group (TODO (osa): not sure what that means)+type RawCmmGroup  = GenCmmGroup RawCmmStatics (LabelMap RawCmmStatics) CmmGraph  ----------------------------------------------------------------------------- --  CmmDecl, GenCmmDecl@@ -89,12 +92,13 @@         Section         d -type CmmDecl = GenCmmDecl CmmStatics CmmTopInfo CmmGraph+type CmmDecl     = GenCmmDecl CmmStatics    CmmTopInfo CmmGraph+type CmmDeclSRTs = GenCmmDecl RawCmmStatics CmmTopInfo CmmGraph  type RawCmmDecl    = GenCmmDecl-        CmmStatics-        (LabelMap CmmStatics)+        RawCmmStatics+        (LabelMap RawCmmStatics)         CmmGraph  -----------------------------------------------------------------------------@@ -199,8 +203,20 @@   | CmmString ByteString         -- string of 8-bit values only, not zero terminated. +-- Static data before SRT generation data CmmStatics-   = Statics+  = CmmStatics+      CLabel       -- Label of statics+      CmmInfoTable+      CostCentreStack+      [CmmLit]     -- Payload+  | CmmStaticsRaw+      CLabel       -- Label of statics+      [CmmStatic]  -- The static data itself++-- Static data, after SRTs are generated+data RawCmmStatics+   = RawCmmStatics        CLabel      -- Label of statics        [CmmStatic] -- The static data itself

compiler/GHC/Cmm/CLabel.hs view

@@ -7,6 +7,7 @@ -----------------------------------------------------------------------------  {-# LANGUAGE CPP #-}+{-# LANGUAGE BangPatterns #-}  module GHC.Cmm.CLabel (         CLabel, -- abstract type@@ -106,7 +107,8 @@          pprCLabel,         isInfoTableLabel,-        isConInfoTableLabel+        isConInfoTableLabel,+        isIdLabel     ) where  #include "HsVersions.h"@@ -116,7 +118,7 @@ import IdInfo import BasicTypes import {-# SOURCE #-} GHC.Cmm.BlockId (BlockId, mkBlockId)-import Packages+import GHC.Driver.Packages import Module import Name import Unique@@ -124,11 +126,11 @@ import CostCentre import Outputable import FastString-import DynFlags+import GHC.Driver.Session import GHC.Platform import UniqSet import Util-import PprCore ( {- instances -} )+import GHC.Core.Ppr ( {- instances -} )  -- ----------------------------------------------------------------------------- -- The CLabel type@@ -262,6 +264,10 @@    deriving Eq +isIdLabel :: CLabel -> Bool+isIdLabel IdLabel{} = True+isIdLabel _ = False+ -- This is laborious, but necessary. We can't derive Ord because -- Unique doesn't have an Ord instance. Note nonDetCmpUnique in the -- implementation. See Note [No Ord for Unique]@@ -463,7 +469,7 @@ mkLocalClosureLabel      :: Name -> CafInfo -> CLabel mkLocalInfoTableLabel    :: Name -> CafInfo -> CLabel mkLocalClosureTableLabel :: Name -> CafInfo -> CLabel-mkLocalClosureLabel     name c  = IdLabel name  c Closure+mkLocalClosureLabel   !name !c  = IdLabel name  c Closure mkLocalInfoTableLabel   name c  = IdLabel name  c LocalInfoTable mkLocalClosureTableLabel name c = IdLabel name  c ClosureTable

compiler/GHC/Cmm/Dataflow/Collections.hs view

@@ -167,11 +167,14 @@   mapFoldr k z (UM m) = M.foldr k z m   mapFoldlWithKey k z (UM m) = M.foldlWithKey' k z m   mapFoldMapWithKey f (UM m) = M.foldMapWithKey f m+  {-# INLINEABLE mapFilter #-}   mapFilter f (UM m) = UM (M.filter f m)+  {-# INLINEABLE mapFilterWithKey #-}   mapFilterWithKey f (UM m) = UM (M.filterWithKey f m)    mapElems (UM m) = M.elems m   mapKeys (UM m) = M.keys m+  {-# INLINEABLE mapToList #-}   mapToList (UM m) = M.toList m   mapFromList assocs = UM (M.fromList assocs)   mapFromListWith f assocs = UM (M.fromListWith f assocs)

compiler/GHC/Cmm/Dataflow/Graph.hs view

@@ -27,11 +27,13 @@ import GHC.Cmm.Dataflow.Block import GHC.Cmm.Dataflow.Collections +import Data.Kind+ -- | A (possibly empty) collection of closed/closed blocks type Body n = LabelMap (Block n C C)  -- | @Body@ abstracted over @block@-type Body' block (n :: Extensibility -> Extensibility -> *) = LabelMap (block n C C)+type Body' block (n :: Extensibility -> Extensibility -> Type) = LabelMap (block n C C)  ------------------------------- -- | Gives access to the anchor points for@@ -76,7 +78,7 @@ -- | @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 :: Extensibility -> Extensibility -> *) e x where+data Graph' block (n :: Extensibility -> Extensibility -> Type) 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)

compiler/GHC/Cmm/Dataflow/Label.hs view

@@ -107,11 +107,14 @@   mapFoldlWithKey k z (LM m) =       mapFoldlWithKey (\a v -> k a (mkHooplLabel v)) z m   mapFoldMapWithKey f (LM m) = mapFoldMapWithKey (\k v -> f (mkHooplLabel k) v) m+  {-# INLINEABLE mapFilter #-}   mapFilter f (LM m) = LM (mapFilter f m)+  {-# INLINEABLE mapFilterWithKey #-}   mapFilterWithKey f (LM m) = LM (mapFilterWithKey (f . mkHooplLabel) m)    mapElems (LM m) = mapElems m   mapKeys (LM m) = map mkHooplLabel (mapKeys m)+  {-# INLINEABLE mapToList #-}   mapToList (LM m) = [(mkHooplLabel 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])

compiler/GHC/Cmm/Expr.hs view

@@ -36,7 +36,7 @@ import GHC.Cmm.CLabel import GHC.Cmm.MachOp import GHC.Cmm.Type-import DynFlags+import GHC.Driver.Session import Outputable (panic) import Unique

compiler/GHC/Cmm/MachOp.hs view

@@ -32,7 +32,7 @@  import GHC.Cmm.Type import Outputable-import DynFlags+import GHC.Driver.Session  ----------------------------------------------------------------------------- --              MachOp

compiler/GHC/Cmm/Node.hs view

@@ -31,12 +31,12 @@ import GHC.Platform.Regs import GHC.Cmm.Expr import GHC.Cmm.Switch-import DynFlags+import GHC.Driver.Session import FastString import ForeignCall import Outputable-import GHC.Runtime.Layout-import CoreSyn (Tickish)+import GHC.Runtime.Heap.Layout+import GHC.Core (Tickish) import qualified Unique as U  import GHC.Cmm.Dataflow.Block

compiler/GHC/Cmm/Switch.hs view

@@ -15,7 +15,7 @@ import GhcPrelude  import Outputable-import DynFlags+import GHC.Driver.Session import GHC.Cmm.Dataflow.Label (Label)  import Data.Maybe

compiler/GHC/Cmm/Type.hs view

@@ -31,7 +31,7 @@  import GhcPrelude -import DynFlags+import GHC.Driver.Session import FastString import Outputable

+ compiler/GHC/Core.hs view

@@ -0,0 +1,2346 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+-}++{-# LANGUAGE CPP, DeriveDataTypeable, FlexibleContexts #-}+{-# LANGUAGE NamedFieldPuns #-}+{-# LANGUAGE BangPatterns #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}+{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++-- | GHC.Core holds all the main data types for use by for the Glasgow Haskell Compiler midsection+module GHC.Core (+        -- * Main data types+        Expr(..), Alt, Bind(..), AltCon(..), Arg,+        Tickish(..), TickishScoping(..), TickishPlacement(..),+        CoreProgram, CoreExpr, CoreAlt, CoreBind, CoreArg, CoreBndr,+        TaggedExpr, TaggedAlt, TaggedBind, TaggedArg, TaggedBndr(..), deTagExpr,++        -- * In/Out type synonyms+        InId, InBind, InExpr, InAlt, InArg, InType, InKind,+               InBndr, InVar, InCoercion, InTyVar, InCoVar,+        OutId, OutBind, OutExpr, OutAlt, OutArg, OutType, OutKind,+               OutBndr, OutVar, OutCoercion, OutTyVar, OutCoVar, MOutCoercion,++        -- ** 'Expr' construction+        mkLet, mkLets, mkLetNonRec, mkLetRec, mkLams,+        mkApps, mkTyApps, mkCoApps, mkVarApps, mkTyArg,++        mkIntLit, mkIntLitInt,+        mkWordLit, mkWordLitWord,+        mkWord64LitWord64, mkInt64LitInt64,+        mkCharLit, mkStringLit,+        mkFloatLit, mkFloatLitFloat,+        mkDoubleLit, mkDoubleLitDouble,++        mkConApp, mkConApp2, mkTyBind, mkCoBind,+        varToCoreExpr, varsToCoreExprs,++        isId, cmpAltCon, cmpAlt, ltAlt,++        -- ** Simple 'Expr' access functions and predicates+        bindersOf, bindersOfBinds, rhssOfBind, rhssOfAlts,+        collectBinders, collectTyBinders, collectTyAndValBinders,+        collectNBinders,+        collectArgs, stripNArgs, collectArgsTicks, flattenBinds,++        exprToType, exprToCoercion_maybe,+        applyTypeToArg,++        isValArg, isTypeArg, isCoArg, isTyCoArg, valArgCount, valBndrCount,+        isRuntimeArg, isRuntimeVar,++        -- * Tick-related functions+        tickishCounts, tickishScoped, tickishScopesLike, tickishFloatable,+        tickishCanSplit, mkNoCount, mkNoScope,+        tickishIsCode, tickishPlace,+        tickishContains,++        -- * Unfolding data types+        Unfolding(..),  UnfoldingGuidance(..), UnfoldingSource(..),++        -- ** Constructing 'Unfolding's+        noUnfolding, bootUnfolding, evaldUnfolding, mkOtherCon,+        unSaturatedOk, needSaturated, boringCxtOk, boringCxtNotOk,++        -- ** Predicates and deconstruction on 'Unfolding'+        unfoldingTemplate, expandUnfolding_maybe,+        maybeUnfoldingTemplate, otherCons,+        isValueUnfolding, isEvaldUnfolding, isCheapUnfolding,+        isExpandableUnfolding, isConLikeUnfolding, isCompulsoryUnfolding,+        isStableUnfolding, isFragileUnfolding, hasSomeUnfolding,+        isBootUnfolding,+        canUnfold, neverUnfoldGuidance, isStableSource,++        -- * Annotated expression data types+        AnnExpr, AnnExpr'(..), AnnBind(..), AnnAlt,++        -- ** Operations on annotated expressions+        collectAnnArgs, collectAnnArgsTicks,++        -- ** Operations on annotations+        deAnnotate, deAnnotate', deAnnAlt, deAnnBind,+        collectAnnBndrs, collectNAnnBndrs,++        -- * Orphanhood+        IsOrphan(..), isOrphan, notOrphan, chooseOrphanAnchor,++        -- * Core rule data types+        CoreRule(..), RuleBase,+        RuleName, RuleFun, IdUnfoldingFun, InScopeEnv,+        RuleEnv(..), mkRuleEnv, emptyRuleEnv,++        -- ** Operations on 'CoreRule's+        ruleArity, ruleName, ruleIdName, ruleActivation,+        setRuleIdName, ruleModule,+        isBuiltinRule, isLocalRule, isAutoRule,+    ) where++#include "HsVersions.h"++import GhcPrelude++import CostCentre+import VarEnv( InScopeSet )+import Var+import Type+import Coercion+import Name+import NameSet+import NameEnv( NameEnv, emptyNameEnv )+import Literal+import DataCon+import Module+import BasicTypes+import GHC.Driver.Session+import Outputable+import Util+import UniqSet+import SrcLoc     ( RealSrcSpan, containsSpan )+import Binary++import Data.Data hiding (TyCon)+import Data.Int+import Data.Word++infixl 4 `mkApps`, `mkTyApps`, `mkVarApps`, `App`, `mkCoApps`+-- Left associative, so that we can say (f `mkTyApps` xs `mkVarApps` ys)++{-+************************************************************************+*                                                                      *+\subsection{The main data types}+*                                                                      *+************************************************************************++These data types are the heart of the compiler+-}++-- | This is the data type that represents GHCs core intermediate language. Currently+-- GHC uses System FC <https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/> for this purpose,+-- which is closely related to the simpler and better known System F <http://en.wikipedia.org/wiki/System_F>.+--+-- We get from Haskell source to this Core language in a number of stages:+--+-- 1. The source code is parsed into an abstract syntax tree, which is represented+--    by the data type 'GHC.Hs.Expr.HsExpr' with the names being 'RdrName.RdrNames'+--+-- 2. This syntax tree is /renamed/, which attaches a 'Unique.Unique' to every 'RdrName.RdrName'+--    (yielding a 'Name.Name') to disambiguate identifiers which are lexically identical.+--    For example, this program:+--+-- @+--      f x = let f x = x + 1+--            in f (x - 2)+-- @+--+--    Would be renamed by having 'Unique's attached so it looked something like this:+--+-- @+--      f_1 x_2 = let f_3 x_4 = x_4 + 1+--                in f_3 (x_2 - 2)+-- @+--    But see Note [Shadowing] below.+--+-- 3. The resulting syntax tree undergoes type checking (which also deals with instantiating+--    type class arguments) to yield a 'GHC.Hs.Expr.HsExpr' type that has 'Id.Id' as it's names.+--+-- 4. Finally the syntax tree is /desugared/ from the expressive 'GHC.Hs.Expr.HsExpr' type into+--    this 'Expr' type, which has far fewer constructors and hence is easier to perform+--    optimization, analysis and code generation on.+--+-- The type parameter @b@ is for the type of binders in the expression tree.+--+-- The language consists of the following elements:+--+-- *  Variables+--    See Note [Variable occurrences in Core]+--+-- *  Primitive literals+--+-- *  Applications: note that the argument may be a 'Type'.+--    See Note [Core let/app invariant]+--    See Note [Levity polymorphism invariants]+--+-- *  Lambda abstraction+--    See Note [Levity polymorphism invariants]+--+-- *  Recursive and non recursive @let@s. Operationally+--    this corresponds to allocating a thunk for the things+--    bound and then executing the sub-expression.+--+--    See Note [Core letrec invariant]+--    See Note [Core let/app invariant]+--    See Note [Levity polymorphism invariants]+--    See Note [Core type and coercion invariant]+--+-- *  Case expression. Operationally this corresponds to evaluating+--    the scrutinee (expression examined) to weak head normal form+--    and then examining at most one level of resulting constructor (i.e. you+--    cannot do nested pattern matching directly with this).+--+--    The binder gets bound to the value of the scrutinee,+--    and the 'Type' must be that of all the case alternatives+--+--    IMPORTANT: see Note [Case expression invariants]+--+-- *  Cast an expression to a particular type.+--    This is used to implement @newtype@s (a @newtype@ constructor or+--    destructor just becomes a 'Cast' in Core) and GADTs.+--+-- *  Notes. These allow general information to be added to expressions+--    in the syntax tree+--+-- *  A type: this should only show up at the top level of an Arg+--+-- *  A coercion++{- Note [Why does Case have a 'Type' field?]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The obvious alternative is+   exprType (Case scrut bndr alts)+     | (_,_,rhs1):_ <- alts+     = exprType rhs1++But caching the type in the Case constructor+  exprType (Case scrut bndr ty alts) = ty+is better for at least three reasons:++* It works when there are no alternatives (see case invariant 1 above)++* It might be faster in deeply-nested situations.++* It might not be quite the same as (exprType rhs) for one+  of the RHSs in alts. Consider a phantom type synonym+       type S a = Int+   and we want to form the case expression+        case x of { K (a::*) -> (e :: S a) }+   Then exprType of the RHS is (S a), but we cannot make that be+   the 'ty' in the Case constructor because 'a' is simply not in+   scope there. Instead we must expand the synonym to Int before+   putting it in the Case constructor.  See GHC.Core.Utils.mkSingleAltCase.++   So we'd have to do synonym expansion in exprType which would+   be inefficient.++* The type stored in the case is checked with lintInTy. This checks+  (among other things) that it does not mention any variables that are+  not in scope. If we did not have the type there, it would be a bit+  harder for Core Lint to reject case blah of Ex x -> x where+      data Ex = forall a. Ex a.+-}++-- If you edit this type, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+data Expr b+  = Var   Id+  | Lit   Literal+  | App   (Expr b) (Arg b)+  | Lam   b (Expr b)+  | Let   (Bind b) (Expr b)+  | Case  (Expr b) b Type [Alt b]   -- See Note [Case expression invariants]+                                    -- and Note [Why does Case have a 'Type' field?]+  | Cast  (Expr b) Coercion+  | Tick  (Tickish Id) (Expr b)+  | Type  Type+  | Coercion Coercion+  deriving Data++-- | Type synonym for expressions that occur in function argument positions.+-- Only 'Arg' should contain a 'Type' at top level, general 'Expr' should not+type Arg b = Expr b++-- | A case split alternative. Consists of the constructor leading to the alternative,+-- the variables bound from the constructor, and the expression to be executed given that binding.+-- The default alternative is @(DEFAULT, [], rhs)@++-- If you edit this type, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+type Alt b = (AltCon, [b], Expr b)++-- | A case alternative constructor (i.e. pattern match)++-- If you edit this type, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+data AltCon+  = DataAlt DataCon   --  ^ A plain data constructor: @case e of { Foo x -> ... }@.+                      -- Invariant: the 'DataCon' is always from a @data@ type, and never from a @newtype@++  | LitAlt  Literal   -- ^ A literal: @case e of { 1 -> ... }@+                      -- Invariant: always an *unlifted* literal+                      -- See Note [Literal alternatives]++  | 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 [Core 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+-- See Note [GHC Formalism] in GHC.Core.Lint+data Bind b = NonRec b (Expr b)+            | Rec [(b, (Expr b))]+  deriving Data++{-+Note [Shadowing]+~~~~~~~~~~~~~~~~+While various passes attempt to rename on-the-fly in a manner that+avoids "shadowing" (thereby simplifying downstream optimizations),+neither the simplifier nor any other pass GUARANTEES that shadowing is+avoided. Thus, all passes SHOULD work fine even in the presence of+arbitrary shadowing in their inputs.++In particular, scrutinee variables `x` in expressions of the form+`Case e x t` are often renamed to variables with a prefix+"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 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+shadowing, you can give a new Unique to an Id without changing its+printable name, which makes debugging easier.++Note [Literal alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Literal alternatives (LitAlt lit) are always for *un-lifted* literals.+We have one literal, a literal Integer, that is lifted, and we don't+allow in a LitAlt, because LitAlt cases don't do any evaluation. Also+(see #5603) if you say+    case 3 of+      S# x -> ...+      J# _ _ -> ...+(where S#, J# are the constructors for Integer) we don't want the+simplifier calling findAlt with argument (LitAlt 3).  No no.  Integer+literals are an opaque encoding of an algebraic data type, not of+an unlifted literal, like all the others.++Also, we do not permit case analysis with literal patterns on floating-point+types. See #9238 and Note [Rules for floating-point comparisons] in+PrelRules for the rationale for this restriction.++-------------------------- GHC.Core INVARIANTS ---------------------------++Note [Variable occurrences in Core]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Variable /occurrences/ are never CoVars, though /bindings/ can be.+All CoVars appear in Coercions.++For example+  \(c :: Age~#Int) (d::Int). d |> (sym c)+Here 'c' is a CoVar, which is lambda-bound, but it /occurs/ in+a Coercion, (sym c).++Note [Core letrec invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The right hand sides of all top-level and recursive @let@s+/must/ be of lifted type (see "Type#type_classification" for+the meaning of /lifted/ vs. /unlifted/).++There is one exception to this rule, top-level @let@s are+allowed to bind primitive string literals: see+Note [Core top-level string literals].++Note [Core top-level string literals]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+As an exception to the usual rule that top-level binders must be lifted,+we allow binding primitive string literals (of type Addr#) of type Addr# at the+top level. This allows us to share string literals earlier in the pipeline and+crucially allows other optimizations in the Core2Core pipeline to fire.+Consider,++  f n = let a::Addr# = "foo"#+        in \x -> blah++In order to be able to inline `f`, we would like to float `a` to the top.+Another option would be to inline `a`, but that would lead to duplicating string+literals, which we want to avoid. See #8472.++The solution is simply to allow top-level unlifted binders. We can't allow+arbitrary unlifted expression at the top-level though, unlifted binders cannot+be thunks, so we just allow string literals.++We allow the top-level primitive string literals to be wrapped in Ticks+in the same way they can be wrapped when nested in an expression.+CoreToSTG currently discards Ticks around top-level primitive string literals.+See #14779.++Also see Note [Compilation plan for top-level string literals].++Note [Compilation plan for top-level string literals]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Here is a summary on how top-level string literals are handled by various+parts of the compilation pipeline.++* In the source language, there is no way to bind a primitive string literal+  at the top level.++* In Core, we have a special rule that permits top-level Addr# bindings. See+  Note [Core top-level string literals]. Core-to-core passes may introduce+  new top-level string literals.++* In STG, top-level string literals are explicitly represented in the syntax+  tree.++* A top-level string literal may end up exported from a module. In this case,+  in the object file, the content of the exported literal is given a label with+  the _bytes suffix.++Note [Core let/app invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The let/app invariant+     the right hand side of a non-recursive 'Let', and+     the argument of an 'App',+    /may/ be of unlifted type, but only if+    the expression is ok-for-speculation+    or the 'Let' is for a join point.++This means that the let can be floated around+without difficulty. For example, this is OK:++   y::Int# = x +# 1#++But this is not, as it may affect termination if the+expression is floated out:++   y::Int# = fac 4#++In this situation you should use @case@ rather than a @let@. The function+'GHC.Core.Utils.needsCaseBinding' can help you determine which to generate, or+alternatively use 'GHC.Core.Make.mkCoreLet' rather than this constructor directly,+which will generate a @case@ if necessary++The let/app invariant is initially enforced by mkCoreLet and mkCoreApp in+GHC.Core.Make.++For discussion of some implications of the let/app invariant primops see+Note [Checking versus non-checking primops] in PrimOp.++Note [Case expression invariants]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Case expressions are one of the more complicated elements of the Core+language, and come with a number of invariants.  All of them should be+checked by Core Lint.++1. The list of alternatives may be empty;+   See Note [Empty case alternatives]++2. The 'DEFAULT' case alternative must be first in the list,+   if it occurs at all.  Checked in GHC.Core.Lint.checkCaseAlts.++3. The remaining cases are in order of (strictly) increasing+     tag  (for 'DataAlts') or+     lit  (for 'LitAlts').+   This makes finding the relevant constructor easy, and makes+   comparison easier too.   Checked in GHC.Core.Lint.checkCaseAlts.++4. The list of alternatives must be exhaustive. An /exhaustive/ case+   does not necessarily mention all constructors:++   @+        data Foo = Red | Green | Blue+        ... case x of+              Red   -> True+              other -> f (case x of+                              Green -> ...+                              Blue  -> ... ) ...+   @++   The inner case does not need a @Red@ alternative, because @x@+   can't be @Red@ at that program point.++   This is not checked by Core Lint -- it's very hard to do so.+   E.g. suppose that inner case was floated out, thus:+         let a = case x of+                   Green -> ...+                   Blue  -> ... )+         case x of+           Red   -> True+           other -> f a+   Now it's really hard to see that the Green/Blue case is+   exhaustive.  But it is.++   If you have a case-expression that really /isn't/ exhaustive,+   we may generate seg-faults.  Consider the Green/Blue case+   above.  Since there are only two branches we may generate+   code that tests for Green, and if not Green simply /assumes/+   Blue (since, if the case is exhaustive, that's all that+   remains).  Of course, if it's not Blue and we start fetching+   fields that should be in a Blue constructor, we may die+   horribly. See also Note [Core Lint guarantee] in GHC.Core.Lint.++5. Floating-point values must not be scrutinised against literals.+   See #9238 and Note [Rules for floating-point comparisons]+   in PrelRules for rationale.  Checked in lintCaseExpr;+   see the call to isFloatingTy.++6. The 'ty' field of (Case scrut bndr ty alts) is the type of the+   /entire/ case expression.  Checked in lintAltExpr.+   See also Note [Why does Case have a 'Type' field?].++7. The type of the scrutinee must be the same as the type+   of the case binder, obviously.  Checked in lintCaseExpr.++Note [Core type and coercion invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We allow a /non-recursive/, /non-top-level/ let to bind type and+coercion variables.  These can be very convenient for postponing type+substitutions until the next run of the simplifier.++* A type variable binding must have a RHS of (Type ty)++* A coercion variable binding must have a RHS of (Coercion co)++  It is possible to have terms that return a coercion, but we use+  case-binding for those; e.g.+     case (eq_sel d) of (co :: a ~# b) -> blah+  where eq_sel :: (a~b) -> (a~#b)++  Or even even+      case (df @Int) of (co :: a ~# b) -> blah+  Which is very exotic, and I think never encountered; but see+  Note [Equality superclasses in quantified constraints]+  in TcCanonical++Note [Core case invariants]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+See Note [Case expression invariants]++Note [Levity polymorphism invariants]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+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+     (see Note [Invariants on join points])++* The type of the argument of an App must not be levity-polymorphic.++A type (t::TYPE r) is "levity polymorphic" if 'r' has any free variables.++For example+  \(r::RuntimeRep). \(a::TYPE r). \(x::a). e+is illegal because x's type has kind (TYPE r), which has 'r' free.++See Note [Levity polymorphism checking] in GHC.HsToCore.Monad to see where these+invariants are established for user-written code.++Note [Core let goal]+~~~~~~~~~~~~~~~~~~~~+* The simplifier tries to ensure that if the RHS of a let is a constructor+  application, its arguments are trivial, so that the constructor can be+  inlined vigorously.++Note [Type let]+~~~~~~~~~~~~~~~+See #type_let#++Note [Empty case alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The alternatives of a case expression should be exhaustive.  But+this exhaustive list can be empty!++* A case expression can have empty alternatives if (and only if) the+  scrutinee is bound to raise an exception or diverge. When do we know+  this?  See Note [Bottoming expressions] in GHC.Core.Utils.++* The possibility of empty alternatives is one reason we need a type on+  the case expression: if the alternatives are empty we can't get the+  type from the alternatives!++* In the case of empty types (see Note [Bottoming expressions]), say+    data T+  we do NOT want to replace+    case (x::T) of Bool {}   -->   error Bool "Inaccessible case"+  because x might raise an exception, and *that*'s what we want to see!+  (#6067 is an example.) To preserve semantics we'd have to say+     x `seq` error Bool "Inaccessible case"+  but the 'seq' is just such a case, so we are back to square 1.++* We can use the empty-alternative construct to coerce error values from+  one type to another.  For example++    f :: Int -> Int+    f n = error "urk"++    g :: Int -> (# Char, Bool #)+    g x = case f x of { 0 -> ..., n -> ... }++  Then if we inline f in g's RHS we get+    case (error Int "urk") of (# Char, Bool #) { ... }+  and we can discard the alternatives since the scrutinee is bottom to give+    case (error Int "urk") of (# Char, Bool #) {}++  This is nicer than using an unsafe coerce between Int ~ (# Char,Bool #),+  if for no other reason that we don't need to instantiate the (~) at an+  unboxed type.++* We treat a case expression with empty alternatives as trivial iff+  its scrutinee is (see GHC.Core.Utils.exprIsTrivial).  This is actually+  important; see Note [Empty case is trivial] in GHC.Core.Utils++* An empty case is replaced by its scrutinee during the CoreToStg+  conversion; remember STG is un-typed, so there is no need for+  the empty case to do the type conversion.++Note [Join points]+~~~~~~~~~~~~~~~~~~+In Core, a *join point* is a specially tagged function whose only occurrences+are saturated tail calls. A tail call can appear in these places:++  1. In the branches (not the scrutinee) of a case+  2. Underneath a let (value or join point)+  3. Inside another join point++We write a join-point declaration as+  join j @a @b x y = e1 in e2,+like a let binding but with "join" instead (or "join rec" for "let rec"). Note+that we put the parameters before the = rather than using lambdas; this is+because it's relevant how many parameters the join point takes *as a join+point.* This number is called the *join arity,* distinct from arity because it+counts types as well as values. Note that a join point may return a lambda! So+  join j x = x + 1+is different from+  join j = \x -> x + 1+The former has join arity 1, while the latter has join arity 0.++The identifier for a join point is called a join id or a *label.* An invocation+is called a *jump.* We write a jump using the jump keyword:++  jump j 3++The words *label* and *jump* are evocative of assembly code (or Cmm) for a+reason: join points are indeed compiled as labeled blocks, and jumps become+actual jumps (plus argument passing and stack adjustment). There is no closure+allocated and only a fraction of the function-call overhead. Hence we would+like as many functions as possible to become join points (see OccurAnal) and+the type rules for join points ensure we preserve the properties that make them+efficient.++In the actual AST, a join point is indicated by the IdDetails of the binder: a+local value binding gets 'VanillaId' but a join point gets a 'JoinId' with its+join arity.++For more details, see the paper:++  Luke Maurer, Paul Downen, Zena Ariola, and Simon Peyton Jones. "Compiling+  without continuations." Submitted to PLDI'17.++  https://www.microsoft.com/en-us/research/publication/compiling-without-continuations/++Note [Invariants on join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Join points must follow these invariants:++  1. All occurrences must be tail calls. Each of these tail calls must pass the+     same number of arguments, counting both types and values; we call this the+     "join arity" (to distinguish from regular arity, which only counts values).++     See Note [Join points are less general than the paper]++  2. For join arity n, the right-hand side must begin with at least n lambdas.+     No ticks, no casts, just lambdas!  C.f. GHC.Core.Utils.joinRhsArity.++     2a. Moreover, this same constraint applies to any unfolding of+         the binder.  Reason: if we want to push a continuation into+         the RHS we must push it into the unfolding as well.++     2b. The Arity (in the IdInfo) of a join point is the number of value+         binders in the top n lambdas, where n is the join arity.++         So arity <= join arity; the former counts only value binders+         while the latter counts all binders.+         e.g. Suppose $j has join arity 1+               let j = \x y. e in case x of { A -> j 1; B -> j 2 }+         Then its ordinary arity is also 1, not 2.++         The arity of a join point isn't very important; but short of setting+         it to zero, it is helpful to have an invariant.  E.g. #17294.++  3. If the binding is recursive, then all other bindings in the recursive group+     must also be join points.++  4. The binding's type must not be polymorphic in its return type (as defined+     in Note [The polymorphism rule of join points]).++However, join points have simpler invariants in other ways++  5. A join point can have an unboxed type without the RHS being+     ok-for-speculation (i.e. drop the let/app invariant)+     e.g.  let j :: Int# = factorial x in ...++  6. A join point can have a levity-polymorphic RHS+     e.g.  let j :: r :: TYPE l = fail void# in ...+     This happened in an intermediate program #13394++Examples:++  join j1  x = 1 + x in jump j (jump j x)  -- Fails 1: non-tail call+  join j1' x = 1 + x in if even a+                          then jump j1 a+                          else jump j1 a b -- Fails 1: inconsistent calls+  join j2  x = flip (+) x in j2 1 2        -- Fails 2: not enough lambdas+  join j2' x = \y -> x + y in j3 1         -- Passes: extra lams ok+  join j @a (x :: a) = x                   -- Fails 4: polymorphic in ret type++Invariant 1 applies to left-hand sides of rewrite rules, so a rule for a join+point must have an exact call as its LHS.++Strictly speaking, invariant 3 is redundant, since a call from inside a lazy+binding isn't a tail call. Since a let-bound value can't invoke a free join+point, then, they can't be mutually recursive. (A Core binding group *can*+include spurious extra bindings if the occurrence analyser hasn't run, so+invariant 3 does still need to be checked.) For the rigorous definition of+"tail call", see Section 3 of the paper (Note [Join points]).++Invariant 4 is subtle; see Note [The polymorphism rule of join points].++Invariant 6 is to enable code like this:++  f = \(r :: RuntimeRep) (a :: TYPE r) (x :: T).+      join j :: a+           j = error @r @a "bloop"+      in case x of+           A -> j+           B -> j+           C -> error @r @a "blurp"++Core Lint will check these invariants, anticipating that any binder whose+OccInfo is marked AlwaysTailCalled will become a join point as soon as the+simplifier (or simpleOptPgm) runs.++Note [Join points are less general than the paper]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In the paper "Compiling without continuations", this expression is+perfectly valid:++    join { j = \_ -> e }+    in (case blah of       )+       (  True  -> j void# ) arg+       (  False -> blah    )++assuming 'j' has arity 1.   Here the call to 'j' does not look like a+tail call, but actually everything is fine. See Section 3, "Managing \Delta"+in the paper.++In GHC, however, we adopt a slightly more restrictive subset, in which+join point calls must be tail calls.  I think we /could/ loosen it up, but+in fact the simplifier ensures that we always get tail calls, and it makes+the back end a bit easier I think.  Generally, just less to think about;+nothing deeper than that.++Note [The type of a join point]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A join point has the same type it would have as a function. That is, if it takes+an Int and a Bool and its body produces a String, its type is `Int -> Bool ->+String`. Natural as this may seem, it can be awkward. A join point shouldn't be+thought to "return" in the same sense a function does---a jump is one-way. This+is crucial for understanding how case-of-case interacts with join points:++  case (join+          j :: Int -> Bool -> String+          j x y = ...+        in+          jump j z w) of+    "" -> True+    _  -> False++The simplifier will pull the case into the join point (see Note [Case-of-case+and join points] in Simplify):++  join+    j :: Int -> Bool -> Bool -- changed!+    j x y = case ... of "" -> True+                        _  -> False+  in+    jump j z w++The body of the join point now returns a Bool, so the label `j` has to have its+type updated accordingly. Inconvenient though this may be, it has the advantage+that 'GHC.Core.Utils.exprType' can still return a type for any expression, including+a jump.++This differs from the paper (see Note [Invariants on join points]). In the+paper, we instead give j the type `Int -> Bool -> forall a. a`. Then each jump+carries the "return type" as a parameter, exactly the way other non-returning+functions like `error` work:++  case (join+          j :: Int -> Bool -> forall a. a+          j x y = ...+        in+          jump j z w @String) of+    "" -> True+    _  -> False++Now we can move the case inward and we only have to change the jump:++  join+    j :: Int -> Bool -> forall a. a+    j x y = case ... of "" -> True+                        _  -> False+  in+    jump j z w @Bool++(Core Lint would still check that the body of the join point has the right type;+that type would simply not be reflected in the join id.)++Note [The polymorphism rule of join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Invariant 4 of Note [Invariants on join points] forbids a join point to be+polymorphic in its return type. That is, if its type is++  forall a1 ... ak. t1 -> ... -> tn -> r++where its join arity is k+n, none of the type parameters ai may occur free in r.++In some way, this falls out of the fact that given++  join+     j @a1 ... @ak x1 ... xn = e1+  in e2++then all calls to `j` are in tail-call positions of `e`, and expressions in+tail-call positions in `e` have the same type as `e`.+Therefore the type of `e1` -- the return type of the join point -- must be the+same as the type of e2.+Since the type variables aren't bound in `e2`, its type can't include them, and+thus neither can the type of `e1`.++This unfortunately prevents the `go` in the following code from being a+join-point:++  iter :: forall a. Int -> (a -> a) -> a -> a+  iter @a n f x = go @a n f x+    where+      go :: forall a. Int -> (a -> a) -> a -> a+      go @a 0 _ x = x+      go @a n f x = go @a (n-1) f (f x)++In this case, a static argument transformation would fix that (see+ticket #14620):++  iter :: forall a. Int -> (a -> a) -> a -> a+  iter @a n f x = go' @a n f x+    where+      go' :: Int -> (a -> a) -> a -> a+      go' 0 _ x = x+      go' n f x = go' (n-1) f (f x)++In general, loopification could be employed to do that (see #14068.)++Can we simply drop the requirement, and allow `go` to be a join-point? We+could, and it would work. But we could not longer apply the case-of-join-point+transformation universally. This transformation would do:++  case (join go @a n f x = case n of 0 -> x+                                     n -> go @a (n-1) f (f x)+        in go @Bool n neg True) of+    True -> e1; False -> e2++ ===>++  join go @a n f x = case n of 0 -> case x of True -> e1; False -> e2+                          n -> go @a (n-1) f (f x)+  in go @Bool n neg True++but that is ill-typed, as `x` is type `a`, not `Bool`.+++This also justifies why we do not consider the `e` in `e |> co` to be in+tail position: A cast changes the type, but the type must be the same. But+operationally, casts are vacuous, so this is a bit unfortunate! See #14610 for+ideas how to fix this.++************************************************************************+*                                                                      *+            In/Out type synonyms+*                                                                      *+********************************************************************* -}++{- Many passes apply a substitution, and it's very handy to have type+   synonyms to remind us whether or not the substitution has been applied -}++-- Pre-cloning or substitution+type InBndr     = CoreBndr+type InType     = Type+type InKind     = Kind+type InBind     = CoreBind+type InExpr     = CoreExpr+type InAlt      = CoreAlt+type InArg      = CoreArg+type InCoercion = Coercion++-- Post-cloning or substitution+type OutBndr     = CoreBndr+type OutType     = Type+type OutKind     = Kind+type OutCoercion = Coercion+type OutBind     = CoreBind+type OutExpr     = CoreExpr+type OutAlt      = CoreAlt+type OutArg      = CoreArg+type MOutCoercion = MCoercion+++{- *********************************************************************+*                                                                      *+              Ticks+*                                                                      *+************************************************************************+-}++-- | Allows attaching extra information to points in expressions++-- If you edit this type, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+data Tickish id =+    -- | An @{-# SCC #-}@ profiling annotation, either automatically+    -- added by the desugarer as a result of -auto-all, or added by+    -- the user.+    ProfNote {+      profNoteCC    :: CostCentre, -- ^ the cost centre+      profNoteCount :: !Bool,      -- ^ bump the entry count?+      profNoteScope :: !Bool       -- ^ scopes over the enclosed expression+                                   -- (i.e. not just a tick)+    }++  -- | A "tick" used by HPC to track the execution of each+  -- subexpression in the original source code.+  | HpcTick {+      tickModule :: Module,+      tickId     :: !Int+    }++  -- | A breakpoint for the GHCi debugger.  This behaves like an HPC+  -- tick, but has a list of free variables which will be available+  -- for inspection in GHCi when the program stops at the breakpoint.+  --+  -- NB. we must take account of these Ids when (a) counting free variables,+  -- and (b) substituting (don't substitute for them)+  | Breakpoint+    { breakpointId     :: !Int+    , breakpointFVs    :: [id]  -- ^ the order of this list is important:+                                -- it matches the order of the lists in the+                                -- appropriate entry in GHC.Driver.Types.ModBreaks.+                                --+                                -- Careful about substitution!  See+                                -- Note [substTickish] in GHC.Core.Subst.+    }++  -- | A source note.+  --+  -- Source notes are pure annotations: Their presence should neither+  -- influence compilation nor execution. The semantics are given by+  -- causality: The presence of a source note means that a local+  -- change in the referenced source code span will possibly provoke+  -- the generated code to change. On the flip-side, the functionality+  -- of annotated code *must* be invariant against changes to all+  -- source code *except* the spans referenced in the source notes+  -- (see "Causality of optimized Haskell" paper for details).+  --+  -- Therefore extending the scope of any given source note is always+  -- valid. Note that it is still undesirable though, as this reduces+  -- their usefulness for debugging and profiling. Therefore we will+  -- generally try only to make use of this property where it is+  -- necessary to enable optimizations.+  | SourceNote+    { sourceSpan :: RealSrcSpan -- ^ Source covered+    , sourceName :: String      -- ^ Name for source location+                                --   (uses same names as CCs)+    }++  deriving (Eq, Ord, Data)++-- | A "counting tick" (where tickishCounts is True) is one that+-- counts evaluations in some way.  We cannot discard a counting tick,+-- and the compiler should preserve the number of counting ticks as+-- far as possible.+--+-- However, we still allow the simplifier to increase or decrease+-- sharing, so in practice the actual number of ticks may vary, except+-- that we never change the value from zero to non-zero or vice versa.+tickishCounts :: Tickish id -> Bool+tickishCounts n@ProfNote{} = profNoteCount n+tickishCounts HpcTick{}    = True+tickishCounts Breakpoint{} = True+tickishCounts _            = False+++-- | Specifies the scoping behaviour of ticks. This governs the+-- behaviour of ticks that care about the covered code and the cost+-- associated with it. Important for ticks relating to profiling.+data TickishScoping =+    -- | No scoping: The tick does not care about what code it+    -- covers. Transformations can freely move code inside as well as+    -- outside without any additional annotation obligations+    NoScope++    -- | Soft scoping: We want all code that is covered to stay+    -- covered.  Note that this scope type does not forbid+    -- transformations from happening, as long as all results of+    -- the transformations are still covered by this tick or a copy of+    -- it. For example+    --+    --   let x = tick<...> (let y = foo in bar) in baz+    --     ===>+    --   let x = tick<...> bar; y = tick<...> foo in baz+    --+    -- Is a valid transformation as far as "bar" and "foo" is+    -- concerned, because both still are scoped over by the tick.+    --+    -- Note though that one might object to the "let" not being+    -- covered by the tick any more. However, we are generally lax+    -- with this - constant costs don't matter too much, and given+    -- that the "let" was effectively merged we can view it as having+    -- lost its identity anyway.+    --+    -- Also note that this scoping behaviour allows floating a tick+    -- "upwards" in pretty much any situation. For example:+    --+    --   case foo of x -> tick<...> bar+    --     ==>+    --   tick<...> case foo of x -> bar+    --+    -- While this is always legal, we want to make a best effort to+    -- only make us of this where it exposes transformation+    -- opportunities.+  | SoftScope++    -- | Cost centre scoping: We don't want any costs to move to other+    -- cost-centre stacks. This means we not only want no code or cost+    -- to get moved out of their cost centres, but we also object to+    -- code getting associated with new cost-centre ticks - or+    -- changing the order in which they get applied.+    --+    -- A rule of thumb is that we don't want any code to gain new+    -- annotations. However, there are notable exceptions, for+    -- example:+    --+    --   let f = \y -> foo in tick<...> ... (f x) ...+    --     ==>+    --   tick<...> ... foo[x/y] ...+    --+    -- In-lining lambdas like this is always legal, because inlining a+    -- function does not change the cost-centre stack when the+    -- function is called.+  | CostCentreScope++  deriving (Eq)++-- | Returns the intended scoping rule for a Tickish+tickishScoped :: Tickish id -> TickishScoping+tickishScoped n@ProfNote{}+  | profNoteScope n        = CostCentreScope+  | otherwise              = NoScope+tickishScoped HpcTick{}    = NoScope+tickishScoped Breakpoint{} = CostCentreScope+   -- Breakpoints are scoped: eventually we're going to do call+   -- stacks, but also this helps prevent the simplifier from moving+   -- breakpoints around and changing their result type (see #1531).+tickishScoped SourceNote{} = SoftScope++-- | Returns whether the tick scoping rule is at least as permissive+-- as the given scoping rule.+tickishScopesLike :: Tickish id -> TickishScoping -> Bool+tickishScopesLike t scope = tickishScoped t `like` scope+  where NoScope         `like` _               = True+        _               `like` NoScope         = False+        SoftScope       `like` _               = True+        _               `like` SoftScope       = False+        CostCentreScope `like` _               = True++-- | Returns @True@ for ticks that can be floated upwards easily even+-- where it might change execution counts, such as:+--+--   Just (tick<...> foo)+--     ==>+--   tick<...> (Just foo)+--+-- This is a combination of @tickishSoftScope@ and+-- @tickishCounts@. Note that in principle splittable ticks can become+-- floatable using @mkNoTick@ -- even though there's currently no+-- tickish for which that is the case.+tickishFloatable :: Tickish id -> Bool+tickishFloatable t = t `tickishScopesLike` SoftScope && not (tickishCounts t)++-- | Returns @True@ for a tick that is both counting /and/ scoping and+-- can be split into its (tick, scope) parts using 'mkNoScope' and+-- 'mkNoTick' respectively.+tickishCanSplit :: Tickish id -> Bool+tickishCanSplit ProfNote{profNoteScope = True, profNoteCount = True}+                   = True+tickishCanSplit _  = False++mkNoCount :: Tickish id -> Tickish id+mkNoCount n | not (tickishCounts n)   = n+            | not (tickishCanSplit n) = panic "mkNoCount: Cannot split!"+mkNoCount n@ProfNote{}                = n {profNoteCount = False}+mkNoCount _                           = panic "mkNoCount: Undefined split!"++mkNoScope :: Tickish id -> Tickish id+mkNoScope n | tickishScoped n == NoScope  = n+            | not (tickishCanSplit n)     = panic "mkNoScope: Cannot split!"+mkNoScope n@ProfNote{}                    = n {profNoteScope = False}+mkNoScope _                               = panic "mkNoScope: Undefined split!"++-- | Return @True@ if this source annotation compiles to some backend+-- code. Without this flag, the tickish is seen as a simple annotation+-- that does not have any associated evaluation code.+--+-- What this means that we are allowed to disregard the tick if doing+-- so means that we can skip generating any code in the first place. A+-- typical example is top-level bindings:+--+--   foo = tick<...> \y -> ...+--     ==>+--   foo = \y -> tick<...> ...+--+-- Here there is just no operational difference between the first and+-- the second version. Therefore code generation should simply+-- translate the code as if it found the latter.+tickishIsCode :: Tickish id -> Bool+tickishIsCode SourceNote{} = False+tickishIsCode _tickish     = True  -- all the rest for now+++-- | Governs the kind of expression that the tick gets placed on when+-- annotating for example using @mkTick@. If we find that we want to+-- put a tickish on an expression ruled out here, we try to float it+-- inwards until we find a suitable expression.+data TickishPlacement =++    -- | Place ticks exactly on run-time expressions. We can still+    -- move the tick through pure compile-time constructs such as+    -- other ticks, casts or type lambdas. This is the most+    -- restrictive placement rule for ticks, as all tickishs have in+    -- common that they want to track runtime processes. The only+    -- legal placement rule for counting ticks.+    PlaceRuntime++    -- | As @PlaceRuntime@, but we float the tick through all+    -- lambdas. This makes sense where there is little difference+    -- between annotating the lambda and annotating the lambda's code.+  | PlaceNonLam++    -- | In addition to floating through lambdas, cost-centre style+    -- tickishs can also be moved from constructors, non-function+    -- variables and literals. For example:+    --+    --   let x = scc<...> C (scc<...> y) (scc<...> 3) in ...+    --+    -- Neither the constructor application, the variable or the+    -- literal are likely to have any cost worth mentioning. And even+    -- if y names a thunk, the call would not care about the+    -- evaluation context. Therefore removing all annotations in the+    -- above example is safe.+  | PlaceCostCentre++  deriving (Eq)++-- | Placement behaviour we want for the ticks+tickishPlace :: Tickish id -> TickishPlacement+tickishPlace n@ProfNote{}+  | profNoteCount n        = PlaceRuntime+  | otherwise              = PlaceCostCentre+tickishPlace HpcTick{}     = PlaceRuntime+tickishPlace Breakpoint{}  = PlaceRuntime+tickishPlace SourceNote{}  = PlaceNonLam++-- | Returns whether one tick "contains" the other one, therefore+-- making the second tick redundant.+tickishContains :: Eq b => Tickish b -> Tickish b -> Bool+tickishContains (SourceNote sp1 n1) (SourceNote sp2 n2)+  = containsSpan sp1 sp2 && n1 == n2+    -- compare the String last+tickishContains t1 t2+  = t1 == t2++{-+************************************************************************+*                                                                      *+                Orphans+*                                                                      *+************************************************************************+-}++-- | Is this instance an orphan?  If it is not an orphan, contains an 'OccName'+-- witnessing the instance's non-orphanhood.+-- See Note [Orphans]+data IsOrphan+  = IsOrphan+  | NotOrphan OccName -- The OccName 'n' witnesses the instance's non-orphanhood+                      -- In that case, the instance is fingerprinted as part+                      -- of the definition of 'n's definition+    deriving Data++-- | Returns true if 'IsOrphan' is orphan.+isOrphan :: IsOrphan -> Bool+isOrphan IsOrphan = True+isOrphan _ = False++-- | Returns true if 'IsOrphan' is not an orphan.+notOrphan :: IsOrphan -> Bool+notOrphan NotOrphan{} = True+notOrphan _ = False++chooseOrphanAnchor :: NameSet -> IsOrphan+-- Something (rule, instance) is relate to all the Names in this+-- list. Choose one of them to be an "anchor" for the orphan.  We make+-- the choice deterministic to avoid gratuitous changes in the ABI+-- hash (#4012).  Specifically, use lexicographic comparison of+-- OccName rather than comparing Uniques+--+-- NB: 'minimum' use Ord, and (Ord OccName) works lexicographically+--+chooseOrphanAnchor local_names+  | isEmptyNameSet local_names = IsOrphan+  | otherwise                  = NotOrphan (minimum occs)+  where+    occs = map nameOccName $ nonDetEltsUniqSet local_names+    -- It's OK to use nonDetEltsUFM here, see comments above++instance Binary IsOrphan where+    put_ bh IsOrphan = putByte bh 0+    put_ bh (NotOrphan n) = do+        putByte bh 1+        put_ bh n+    get bh = do+        h <- getByte bh+        case h of+            0 -> return IsOrphan+            _ -> do+                n <- get bh+                return $ NotOrphan n++{-+Note [Orphans]+~~~~~~~~~~~~~~+Class instances, rules, and family instances are divided into orphans+and non-orphans.  Roughly speaking, an instance/rule is an orphan if+its left hand side mentions nothing defined in this module.  Orphan-hood+has two major consequences++ * A module that contains orphans is called an "orphan module".  If+   the module being compiled depends (transitively) on an orphan+   module M, then M.hi is read in regardless of whether M is otherwise+   needed. This is to ensure that we don't miss any instance decls in+   M.  But it's painful, because it means we need to keep track of all+   the orphan modules below us.++ * A non-orphan is not finger-printed separately.  Instead, for+   fingerprinting purposes it is treated as part of the entity it+   mentions on the LHS.  For example+      data T = T1 | T2+      instance Eq T where ....+   The instance (Eq T) is incorporated as part of T's fingerprint.++   In contrast, orphans are all fingerprinted together in the+   mi_orph_hash field of the ModIface.++   See GHC.Iface.Utils.addFingerprints.++Orphan-hood is computed+  * For class instances:+      when we make a ClsInst+    (because it is needed during instance lookup)++  * For rules and family instances:+       when we generate an IfaceRule (GHC.Iface.Utils.coreRuleToIfaceRule)+                     or IfaceFamInst (GHC.Iface.Utils.instanceToIfaceInst)+-}++{-+************************************************************************+*                                                                      *+\subsection{Transformation rules}+*                                                                      *+************************************************************************++The CoreRule type and its friends are dealt with mainly in GHC.Core.Rules, but+GHC.Core.FVs, GHC.Core.Subst, GHC.Core.Ppr, GHC.Core.Op.Tidy also inspect the+representation.+-}++-- | Gathers a collection of 'CoreRule's. Maps (the name of) an 'Id' to its rules+type RuleBase = NameEnv [CoreRule]+        -- The rules are unordered;+        -- we sort out any overlaps on lookup++-- | A full rule environment which we can apply rules from.  Like a 'RuleBase',+-- but it also includes the set of visible orphans we use to filter out orphan+-- rules which are not visible (even though we can see them...)+data RuleEnv+    = RuleEnv { re_base          :: RuleBase+              , re_visible_orphs :: ModuleSet+              }++mkRuleEnv :: RuleBase -> [Module] -> RuleEnv+mkRuleEnv rules vis_orphs = RuleEnv rules (mkModuleSet vis_orphs)++emptyRuleEnv :: RuleEnv+emptyRuleEnv = RuleEnv emptyNameEnv emptyModuleSet++-- | A 'CoreRule' is:+--+-- * \"Local\" if the function it is a rule for is defined in the+--   same module as the rule itself.+--+-- * \"Orphan\" if nothing on the LHS is defined in the same module+--   as the rule itself+data CoreRule+  = Rule {+        ru_name :: RuleName,            -- ^ Name of the rule, for communication with the user+        ru_act  :: Activation,          -- ^ When the rule is active++        -- Rough-matching stuff+        -- see comments with InstEnv.ClsInst( is_cls, is_rough )+        ru_fn    :: Name,               -- ^ Name of the 'Id.Id' at the head of this rule+        ru_rough :: [Maybe Name],       -- ^ Name at the head of each argument to the left hand side++        -- Proper-matching stuff+        -- see comments with InstEnv.ClsInst( is_tvs, is_tys )+        ru_bndrs :: [CoreBndr],         -- ^ Variables quantified over+        ru_args  :: [CoreExpr],         -- ^ Left hand side arguments++        -- And the right-hand side+        ru_rhs   :: CoreExpr,           -- ^ Right hand side of the rule+                                        -- Occurrence info is guaranteed correct+                                        -- See Note [OccInfo in unfoldings and rules]++        -- Locality+        ru_auto :: Bool,   -- ^ @True@  <=> this rule is auto-generated+                           --               (notably by Specialise or SpecConstr)+                           --   @False@ <=> generated at the user's behest+                           -- See Note [Trimming auto-rules] in GHC.Iface.Tidy+                           -- for the sole purpose of this field.++        ru_origin :: !Module,   -- ^ 'Module' the rule was defined in, used+                                -- to test if we should see an orphan rule.++        ru_orphan :: !IsOrphan, -- ^ Whether or not the rule is an orphan.++        ru_local :: Bool        -- ^ @True@ iff the fn at the head of the rule is+                                -- defined in the same module as the rule+                                -- and is not an implicit 'Id' (like a record selector,+                                -- class operation, or data constructor).  This+                                -- is different from 'ru_orphan', where a rule+                                -- can avoid being an orphan if *any* Name in+                                -- LHS of the rule was defined in the same+                                -- module as the rule.+    }++  -- | Built-in rules are used for constant folding+  -- and suchlike.  They have no free variables.+  -- A built-in rule is always visible (there is no such thing as+  -- an orphan built-in rule.)+  | BuiltinRule {+        ru_name  :: RuleName,   -- ^ As above+        ru_fn    :: Name,       -- ^ As above+        ru_nargs :: Int,        -- ^ Number of arguments that 'ru_try' consumes,+                                -- if it fires, including type arguments+        ru_try   :: RuleFun+                -- ^ This function does the rewrite.  It given too many+                -- arguments, it simply discards them; the returned 'CoreExpr'+                -- is just the rewrite of 'ru_fn' applied to the first 'ru_nargs' args+    }+                -- See Note [Extra args in rule matching] in GHC.Core.Rules++type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr+type InScopeEnv = (InScopeSet, IdUnfoldingFun)++type IdUnfoldingFun = Id -> Unfolding+-- A function that embodies how to unfold an Id if you need+-- to do that in the Rule.  The reason we need to pass this info in+-- is that whether an Id is unfoldable depends on the simplifier phase++isBuiltinRule :: CoreRule -> Bool+isBuiltinRule (BuiltinRule {}) = True+isBuiltinRule _                = False++isAutoRule :: CoreRule -> Bool+isAutoRule (BuiltinRule {}) = False+isAutoRule (Rule { ru_auto = is_auto }) = is_auto++-- | The number of arguments the 'ru_fn' must be applied+-- to before the rule can match on it+ruleArity :: CoreRule -> Int+ruleArity (BuiltinRule {ru_nargs = n}) = n+ruleArity (Rule {ru_args = args})      = length args++ruleName :: CoreRule -> RuleName+ruleName = ru_name++ruleModule :: CoreRule -> Maybe Module+ruleModule Rule { ru_origin } = Just ru_origin+ruleModule BuiltinRule {} = Nothing++ruleActivation :: CoreRule -> Activation+ruleActivation (BuiltinRule { })       = AlwaysActive+ruleActivation (Rule { ru_act = act }) = act++-- | The 'Name' of the 'Id.Id' at the head of the rule left hand side+ruleIdName :: CoreRule -> Name+ruleIdName = ru_fn++isLocalRule :: CoreRule -> Bool+isLocalRule = ru_local++-- | Set the 'Name' of the 'Id.Id' at the head of the rule left hand side+setRuleIdName :: Name -> CoreRule -> CoreRule+setRuleIdName nm ru = ru { ru_fn = nm }++{-+************************************************************************+*                                                                      *+                Unfoldings+*                                                                      *+************************************************************************++The @Unfolding@ type is declared here to avoid numerous loops+-}++-- | Records the /unfolding/ of an identifier, which is approximately the form the+-- identifier would have if we substituted its definition in for the identifier.+-- This type should be treated as abstract everywhere except in GHC.Core.Unfold+data Unfolding+  = NoUnfolding        -- ^ We have no information about the unfolding.++  | BootUnfolding      -- ^ We have no information about the unfolding, because+                       -- this 'Id' came from an @hi-boot@ file.+                       -- See Note [Inlining and hs-boot files] in GHC.CoreToIface+                       -- for what this is used for.++  | OtherCon [AltCon]  -- ^ It ain't one of these constructors.+                       -- @OtherCon xs@ also indicates that something has been evaluated+                       -- and hence there's no point in re-evaluating it.+                       -- @OtherCon []@ is used even for non-data-type values+                       -- to indicated evaluated-ness.  Notably:+                       --+                       -- > data C = C !(Int -> Int)+                       -- > case x of { C f -> ... }+                       --+                       -- Here, @f@ gets an @OtherCon []@ unfolding.++  | DFunUnfolding {     -- The Unfolding of a DFunId+                        -- See Note [DFun unfoldings]+                        --     df = /\a1..am. \d1..dn. MkD t1 .. tk+                        --                                 (op1 a1..am d1..dn)+                        --                                 (op2 a1..am d1..dn)+        df_bndrs :: [Var],      -- The bound variables [a1..m],[d1..dn]+        df_con   :: DataCon,    -- The dictionary data constructor (never a newtype datacon)+        df_args  :: [CoreExpr]  -- Args of the data con: types, superclasses and methods,+    }                           -- in positional order++  | CoreUnfolding {             -- An unfolding for an Id with no pragma,+                                -- or perhaps a NOINLINE pragma+                                -- (For NOINLINE, the phase, if any, is in the+                                -- InlinePragInfo for this Id.)+        uf_tmpl       :: CoreExpr,        -- Template; occurrence info is correct+        uf_src        :: UnfoldingSource, -- Where the unfolding came from+        uf_is_top     :: Bool,          -- True <=> top level binding+        uf_is_value   :: Bool,          -- exprIsHNF template (cached); it is ok to discard+                                        --      a `seq` on this variable+        uf_is_conlike :: Bool,          -- True <=> applicn of constructor or CONLIKE function+                                        --      Cached version of exprIsConLike+        uf_is_work_free :: Bool,                -- True <=> doesn't waste (much) work to expand+                                        --          inside an inlining+                                        --      Cached version of exprIsCheap+        uf_expandable :: Bool,          -- True <=> can expand in RULE matching+                                        --      Cached version of exprIsExpandable+        uf_guidance   :: UnfoldingGuidance      -- Tells about the *size* of the template.+    }+  -- ^ An unfolding with redundant cached information. Parameters:+  --+  --  uf_tmpl: Template used to perform unfolding;+  --           NB: Occurrence info is guaranteed correct:+  --               see Note [OccInfo in unfoldings and rules]+  --+  --  uf_is_top: Is this a top level binding?+  --+  --  uf_is_value: 'exprIsHNF' template (cached); it is ok to discard a 'seq' on+  --     this variable+  --+  --  uf_is_work_free:  Does this waste only a little work if we expand it inside an inlining?+  --     Basically this is a cached version of 'exprIsWorkFree'+  --+  --  uf_guidance:  Tells us about the /size/ of the unfolding template+++------------------------------------------------+data UnfoldingSource+  = -- See also Note [Historical note: unfoldings for wrappers]++    InlineRhs          -- The current rhs of the function+                       -- Replace uf_tmpl each time around++  | InlineStable       -- From an INLINE or INLINABLE pragma+                       --   INLINE     if guidance is UnfWhen+                       --   INLINABLE  if guidance is UnfIfGoodArgs/UnfoldNever+                       -- (well, technically an INLINABLE might be made+                       -- UnfWhen if it was small enough, and then+                       -- it will behave like INLINE outside the current+                       -- module, but that is the way automatic unfoldings+                       -- work so it is consistent with the intended+                       -- meaning of INLINABLE).+                       --+                       -- uf_tmpl may change, but only as a result of+                       -- gentle simplification, it doesn't get updated+                       -- to the current RHS during compilation as with+                       -- InlineRhs.+                       --+                       -- See Note [InlineStable]++  | InlineCompulsory   -- Something that *has* no binding, so you *must* inline it+                       -- Only a few primop-like things have this property+                       -- (see MkId.hs, calls to mkCompulsoryUnfolding).+                       -- Inline absolutely always, however boring the context.++++-- | 'UnfoldingGuidance' says when unfolding should take place+data UnfoldingGuidance+  = UnfWhen {   -- Inline without thinking about the *size* of the uf_tmpl+                -- Used (a) for small *and* cheap unfoldings+                --      (b) for INLINE functions+                -- See Note [INLINE for small functions] in GHC.Core.Unfold+      ug_arity    :: Arity,     -- Number of value arguments expected++      ug_unsat_ok  :: Bool,     -- True <=> ok to inline even if unsaturated+      ug_boring_ok :: Bool      -- True <=> ok to inline even if the context is boring+                -- So True,True means "always"+    }++  | UnfIfGoodArgs {     -- Arose from a normal Id; the info here is the+                        -- result of a simple analysis of the RHS++      ug_args ::  [Int],  -- Discount if the argument is evaluated.+                          -- (i.e., a simplification will definitely+                          -- be possible).  One elt of the list per *value* arg.++      ug_size :: Int,     -- The "size" of the unfolding.++      ug_res :: Int       -- Scrutinee discount: the discount to subtract if the thing is in+    }                     -- a context (case (thing args) of ...),+                          -- (where there are the right number of arguments.)++  | UnfNever        -- The RHS is big, so don't inline it+  deriving (Eq)++{-+Note [Historical note: unfoldings for wrappers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We used to have a nice clever scheme in interface files for+wrappers. A wrapper's unfolding can be reconstructed from its worker's+id and its strictness. This decreased .hi file size (sometimes+significantly, for modules like GHC.Classes with many high-arity w/w+splits) and had a slight corresponding effect on compile times.++However, when we added the second demand analysis, this scheme lead to+some Core lint errors. The second analysis could change the strictness+signatures, which sometimes resulted in a wrapper's regenerated+unfolding applying the wrapper to too many arguments.++Instead of repairing the clever .hi scheme, we abandoned it in favor+of simplicity. The .hi sizes are usually insignificant (excluding the++1M for base libraries), and compile time barely increases (~+1% for+nofib). The nicer upshot is that the UnfoldingSource no longer mentions+an Id, so, eg, substitutions need not traverse them.+++Note [DFun unfoldings]+~~~~~~~~~~~~~~~~~~~~~~+The Arity in a DFunUnfolding is total number of args (type and value)+that the DFun needs to produce a dictionary.  That's not necessarily+related to the ordinary arity of the dfun Id, esp if the class has+one method, so the dictionary is represented by a newtype.  Example++     class C a where { op :: a -> Int }+     instance C a -> C [a] where op xs = op (head xs)++The instance translates to++     $dfCList :: forall a. C a => C [a]  -- Arity 2!+     $dfCList = /\a.\d. $copList {a} d |> co++     $copList :: forall a. C a => [a] -> Int  -- Arity 2!+     $copList = /\a.\d.\xs. op {a} d (head xs)++Now we might encounter (op (dfCList {ty} d) a1 a2)+and we want the (op (dfList {ty} d)) rule to fire, because $dfCList+has all its arguments, even though its (value) arity is 2.  That's+why we record the number of expected arguments in the DFunUnfolding.++Note that although it's an Arity, it's most convenient for it to give+the *total* number of arguments, both type and value.  See the use+site in exprIsConApp_maybe.+-}++-- Constants for the UnfWhen constructor+needSaturated, unSaturatedOk :: Bool+needSaturated = False+unSaturatedOk = True++boringCxtNotOk, boringCxtOk :: Bool+boringCxtOk    = True+boringCxtNotOk = False++------------------------------------------------+noUnfolding :: Unfolding+-- ^ There is no known 'Unfolding'+evaldUnfolding :: Unfolding+-- ^ This unfolding marks the associated thing as being evaluated++noUnfolding    = NoUnfolding+evaldUnfolding = OtherCon []++-- | There is no known 'Unfolding', because this came from an+-- hi-boot file.+bootUnfolding :: Unfolding+bootUnfolding = BootUnfolding++mkOtherCon :: [AltCon] -> Unfolding+mkOtherCon = OtherCon++isStableSource :: UnfoldingSource -> Bool+-- Keep the unfolding template+isStableSource InlineCompulsory   = True+isStableSource InlineStable       = True+isStableSource InlineRhs          = False++-- | Retrieves the template of an unfolding: panics if none is known+unfoldingTemplate :: Unfolding -> CoreExpr+unfoldingTemplate = uf_tmpl++-- | Retrieves the template of an unfolding if possible+-- maybeUnfoldingTemplate is used mainly wnen specialising, and we do+-- want to specialise DFuns, so it's important to return a template+-- for DFunUnfoldings+maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr+maybeUnfoldingTemplate (CoreUnfolding { uf_tmpl = expr })+  = Just expr+maybeUnfoldingTemplate (DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = args })+  = Just (mkLams bndrs (mkApps (Var (dataConWorkId con)) args))+maybeUnfoldingTemplate _+  = Nothing++-- | The constructors that the unfolding could never be:+-- returns @[]@ if no information is available+otherCons :: Unfolding -> [AltCon]+otherCons (OtherCon cons) = cons+otherCons _               = []++-- | Determines if it is certainly the case that the unfolding will+-- yield a value (something in HNF): returns @False@ if unsure+isValueUnfolding :: Unfolding -> Bool+        -- Returns False for OtherCon+isValueUnfolding (CoreUnfolding { uf_is_value = is_evald }) = is_evald+isValueUnfolding _                                          = False++-- | Determines if it possibly the case that the unfolding will+-- yield a value. Unlike 'isValueUnfolding' it returns @True@+-- for 'OtherCon'+isEvaldUnfolding :: Unfolding -> Bool+        -- Returns True for OtherCon+isEvaldUnfolding (OtherCon _)                               = True+isEvaldUnfolding (CoreUnfolding { uf_is_value = is_evald }) = is_evald+isEvaldUnfolding _                                          = False++-- | @True@ if the unfolding is a constructor application, the application+-- of a CONLIKE function or 'OtherCon'+isConLikeUnfolding :: Unfolding -> Bool+isConLikeUnfolding (OtherCon _)                             = True+isConLikeUnfolding (CoreUnfolding { uf_is_conlike = con })  = con+isConLikeUnfolding _                                        = False++-- | Is the thing we will unfold into certainly cheap?+isCheapUnfolding :: Unfolding -> Bool+isCheapUnfolding (CoreUnfolding { uf_is_work_free = is_wf }) = is_wf+isCheapUnfolding _                                           = False++isExpandableUnfolding :: Unfolding -> Bool+isExpandableUnfolding (CoreUnfolding { uf_expandable = is_expable }) = is_expable+isExpandableUnfolding _                                              = False++expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr+-- Expand an expandable unfolding; this is used in rule matching+--   See Note [Expanding variables] in GHC.Core.Rules+-- The key point here is that CONLIKE things can be expanded+expandUnfolding_maybe (CoreUnfolding { uf_expandable = True, uf_tmpl = rhs }) = Just rhs+expandUnfolding_maybe _                                                       = Nothing++isCompulsoryUnfolding :: Unfolding -> Bool+isCompulsoryUnfolding (CoreUnfolding { uf_src = InlineCompulsory }) = True+isCompulsoryUnfolding _                                             = False++isStableUnfolding :: Unfolding -> Bool+-- True of unfoldings that should not be overwritten+-- by a CoreUnfolding for the RHS of a let-binding+isStableUnfolding (CoreUnfolding { uf_src = src }) = isStableSource src+isStableUnfolding (DFunUnfolding {})               = True+isStableUnfolding _                                = False++-- | Only returns False if there is no unfolding information available at all+hasSomeUnfolding :: Unfolding -> Bool+hasSomeUnfolding NoUnfolding   = False+hasSomeUnfolding BootUnfolding = False+hasSomeUnfolding _             = True++isBootUnfolding :: Unfolding -> Bool+isBootUnfolding BootUnfolding = True+isBootUnfolding _             = False++neverUnfoldGuidance :: UnfoldingGuidance -> Bool+neverUnfoldGuidance UnfNever = True+neverUnfoldGuidance _        = False++isFragileUnfolding :: Unfolding -> Bool+-- An unfolding is fragile if it mentions free variables or+-- is otherwise subject to change.  A robust one can be kept.+-- See Note [Fragile unfoldings]+isFragileUnfolding (CoreUnfolding {}) = True+isFragileUnfolding (DFunUnfolding {}) = True+isFragileUnfolding _                  = False+  -- NoUnfolding, BootUnfolding, OtherCon are all non-fragile++canUnfold :: Unfolding -> Bool+canUnfold (CoreUnfolding { uf_guidance = g }) = not (neverUnfoldGuidance g)+canUnfold _                                   = False++{- Note [Fragile unfoldings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+An unfolding is "fragile" if it mentions free variables (and hence would+need substitution) or might be affected by optimisation.  The non-fragile+ones are++   NoUnfolding, BootUnfolding++   OtherCon {}    If we know this binder (say a lambda binder) will be+                  bound to an evaluated thing, we want to retain that+                  info in simpleOptExpr; see #13077.++We consider even a StableUnfolding as fragile, because it needs substitution.++Note [InlineStable]+~~~~~~~~~~~~~~~~~+When you say+      {-# INLINE f #-}+      f x = <rhs>+you intend that calls (f e) are replaced by <rhs>[e/x] So we+should capture (\x.<rhs>) in the Unfolding of 'f', and never meddle+with it.  Meanwhile, we can optimise <rhs> to our heart's content,+leaving the original unfolding intact in Unfolding of 'f'. For example+        all xs = foldr (&&) True xs+        any p = all . map p  {-# INLINE any #-}+We optimise any's RHS fully, but leave the InlineRule saying "all . map p",+which deforests well at the call site.++So INLINE pragma gives rise to an InlineRule, which captures the original RHS.++Moreover, it's only used when 'f' is applied to the+specified number of arguments; that is, the number of argument on+the LHS of the '=' sign in the original source definition.+For example, (.) is now defined in the libraries like this+   {-# INLINE (.) #-}+   (.) f g = \x -> f (g x)+so that it'll inline when applied to two arguments. If 'x' appeared+on the left, thus+   (.) f g x = f (g x)+it'd only inline when applied to three arguments.  This slightly-experimental+change was requested by Roman, but it seems to make sense.++See also Note [Inlining an InlineRule] in GHC.Core.Unfold.+++Note [OccInfo in unfoldings and rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In unfoldings and rules, we guarantee that the template is occ-analysed,+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 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+++************************************************************************+*                                                                      *+                  AltCon+*                                                                      *+************************************************************************+-}++-- The Ord is needed for the FiniteMap used in the lookForConstructor+-- in SimplEnv.  If you declared that lookForConstructor *ignores*+-- constructor-applications with LitArg args, then you could get+-- rid of this Ord.++instance Outputable AltCon where+  ppr (DataAlt dc) = ppr dc+  ppr (LitAlt lit) = ppr lit+  ppr DEFAULT      = text "__DEFAULT"++cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering+cmpAlt (con1, _, _) (con2, _, _) = con1 `cmpAltCon` con2++ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool+ltAlt a1 a2 = (a1 `cmpAlt` a2) == LT++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: see Note [Case expression invariants]+cmpAltCon DEFAULT      DEFAULT     = EQ+cmpAltCon DEFAULT      _           = LT++cmpAltCon (DataAlt d1) (DataAlt d2) = dataConTag d1 `compare` dataConTag d2+cmpAltCon (DataAlt _)  DEFAULT      = GT+cmpAltCon (LitAlt  l1) (LitAlt  l2) = l1 `compare` l2+cmpAltCon (LitAlt _)   DEFAULT      = GT++cmpAltCon con1 con2 = WARN( True, text "Comparing incomparable AltCons" <+>+                                  ppr con1 <+> ppr con2 )+                      LT++{-+************************************************************************+*                                                                      *+\subsection{Useful synonyms}+*                                                                      *+************************************************************************++Note [CoreProgram]+~~~~~~~~~~~~~~~~~~+The top level bindings of a program, a CoreProgram, are represented as+a list of CoreBind++ * Later bindings in the list can refer to earlier ones, but not vice+   versa.  So this is OK+      NonRec { x = 4 }+      Rec { p = ...q...x...+          ; q = ...p...x }+      Rec { f = ...p..x..f.. }+      NonRec { g = ..f..q...x.. }+   But it would NOT be ok for 'f' to refer to 'g'.++ * The occurrence analyser does strongly-connected component analysis+   on each Rec binding, and splits it into a sequence of smaller+   bindings where possible.  So the program typically starts life as a+   single giant Rec, which is then dependency-analysed into smaller+   chunks.+-}++-- If you edit this type, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+type CoreProgram = [CoreBind]   -- See Note [CoreProgram]++-- | The common case for the type of binders and variables when+-- we are manipulating the Core language within GHC+type CoreBndr = Var+-- | Expressions where binders are 'CoreBndr's+type CoreExpr = Expr CoreBndr+-- | Argument expressions where binders are 'CoreBndr's+type CoreArg  = Arg  CoreBndr+-- | Binding groups where binders are 'CoreBndr's+type CoreBind = Bind CoreBndr+-- | Case alternatives where binders are 'CoreBndr's+type CoreAlt  = Alt  CoreBndr++{-+************************************************************************+*                                                                      *+\subsection{Tagging}+*                                                                      *+************************************************************************+-}++-- | Binders are /tagged/ with a t+data TaggedBndr t = TB CoreBndr t       -- TB for "tagged binder"++type TaggedBind t = Bind (TaggedBndr t)+type TaggedExpr t = Expr (TaggedBndr t)+type TaggedArg  t = Arg  (TaggedBndr t)+type TaggedAlt  t = Alt  (TaggedBndr t)++instance Outputable b => Outputable (TaggedBndr b) where+  ppr (TB b l) = char '<' <> ppr b <> comma <> ppr l <> char '>'++deTagExpr :: TaggedExpr t -> CoreExpr+deTagExpr (Var v)                   = Var v+deTagExpr (Lit l)                   = Lit l+deTagExpr (Type ty)                 = Type ty+deTagExpr (Coercion co)             = Coercion co+deTagExpr (App e1 e2)               = App (deTagExpr e1) (deTagExpr e2)+deTagExpr (Lam (TB b _) e)          = Lam b (deTagExpr e)+deTagExpr (Let bind body)           = Let (deTagBind bind) (deTagExpr body)+deTagExpr (Case e (TB b _) ty alts) = Case (deTagExpr e) b ty (map deTagAlt alts)+deTagExpr (Tick t e)                = Tick t (deTagExpr e)+deTagExpr (Cast e co)               = Cast (deTagExpr e) co++deTagBind :: TaggedBind t -> CoreBind+deTagBind (NonRec (TB b _) rhs) = NonRec b (deTagExpr rhs)+deTagBind (Rec prs)             = Rec [(b, deTagExpr rhs) | (TB b _, rhs) <- prs]++deTagAlt :: TaggedAlt t -> CoreAlt+deTagAlt (con, bndrs, rhs) = (con, [b | TB b _ <- bndrs], deTagExpr rhs)++{-+************************************************************************+*                                                                      *+\subsection{Core-constructing functions with checking}+*                                                                      *+************************************************************************+-}++-- | Apply a list of argument expressions to a function expression in a nested fashion. Prefer to+-- use 'GHC.Core.Make.mkCoreApps' if possible+mkApps    :: Expr b -> [Arg b]  -> Expr b+-- | Apply a list of type argument expressions to a function expression in a nested fashion+mkTyApps  :: Expr b -> [Type]   -> Expr b+-- | Apply a list of coercion argument expressions to a function expression in a nested fashion+mkCoApps  :: Expr b -> [Coercion] -> Expr b+-- | Apply a list of type or value variables to a function expression in a nested fashion+mkVarApps :: Expr b -> [Var] -> Expr b+-- | Apply a list of argument expressions to a data constructor in a nested fashion. Prefer to+-- use 'GHC.Core.Make.mkCoreConApps' if possible+mkConApp      :: DataCon -> [Arg b] -> Expr b++mkApps    f args = foldl' App                       f args+mkCoApps  f args = foldl' (\ e a -> App e (Coercion a)) f args+mkVarApps f vars = foldl' (\ e a -> App e (varToCoreExpr a)) f vars+mkConApp con args = mkApps (Var (dataConWorkId con)) args++mkTyApps  f args = foldl' (\ e a -> App e (mkTyArg a)) f args++mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b+mkConApp2 con tys arg_ids = Var (dataConWorkId con)+                            `mkApps` map Type tys+                            `mkApps` map varToCoreExpr arg_ids++mkTyArg :: Type -> Expr b+mkTyArg ty+  | Just co <- isCoercionTy_maybe ty = Coercion co+  | otherwise                        = Type ty++-- | Create a machine integer literal expression of type @Int#@ from an @Integer@.+-- If you want an expression of type @Int@ use 'GHC.Core.Make.mkIntExpr'+mkIntLit      :: DynFlags -> Integer -> Expr b+-- | Create a machine integer literal expression of type @Int#@ from an @Int@.+-- If you want an expression of type @Int@ use 'GHC.Core.Make.mkIntExpr'+mkIntLitInt   :: DynFlags -> Int     -> Expr b++mkIntLit    dflags n = Lit (mkLitInt dflags n)+mkIntLitInt dflags n = Lit (mkLitInt dflags (toInteger n))++-- | Create a machine word literal expression of type  @Word#@ from an @Integer@.+-- If you want an expression of type @Word@ use 'GHC.Core.Make.mkWordExpr'+mkWordLit     :: DynFlags -> Integer -> Expr b+-- | Create a machine word literal expression of type  @Word#@ from a @Word@.+-- If you want an expression of type @Word@ use 'GHC.Core.Make.mkWordExpr'+mkWordLitWord :: DynFlags -> Word -> Expr b++mkWordLit     dflags w = Lit (mkLitWord dflags w)+mkWordLitWord dflags w = Lit (mkLitWord dflags (toInteger w))++mkWord64LitWord64 :: Word64 -> Expr b+mkWord64LitWord64 w = Lit (mkLitWord64 (toInteger w))++mkInt64LitInt64 :: Int64 -> Expr b+mkInt64LitInt64 w = Lit (mkLitInt64 (toInteger w))++-- | Create a machine character literal expression of type @Char#@.+-- If you want an expression of type @Char@ use 'GHC.Core.Make.mkCharExpr'+mkCharLit :: Char -> Expr b+-- | Create a machine string literal expression of type @Addr#@.+-- If you want an expression of type @String@ use 'GHC.Core.Make.mkStringExpr'+mkStringLit :: String -> Expr b++mkCharLit   c = Lit (mkLitChar c)+mkStringLit s = Lit (mkLitString s)++-- | Create a machine single precision literal expression of type @Float#@ from a @Rational@.+-- If you want an expression of type @Float@ use 'GHC.Core.Make.mkFloatExpr'+mkFloatLit :: Rational -> Expr b+-- | Create a machine single precision literal expression of type @Float#@ from a @Float@.+-- If you want an expression of type @Float@ use 'GHC.Core.Make.mkFloatExpr'+mkFloatLitFloat :: Float -> Expr b++mkFloatLit      f = Lit (mkLitFloat f)+mkFloatLitFloat f = Lit (mkLitFloat (toRational f))++-- | Create a machine double precision literal expression of type @Double#@ from a @Rational@.+-- If you want an expression of type @Double@ use 'GHC.Core.Make.mkDoubleExpr'+mkDoubleLit :: Rational -> Expr b+-- | Create a machine double precision literal expression of type @Double#@ from a @Double@.+-- If you want an expression of type @Double@ use 'GHC.Core.Make.mkDoubleExpr'+mkDoubleLitDouble :: Double -> Expr b++mkDoubleLit       d = Lit (mkLitDouble d)+mkDoubleLitDouble d = Lit (mkLitDouble (toRational d))++-- | Bind all supplied binding groups over an expression in a nested let expression. Assumes+-- that the rhs satisfies the let/app invariant.  Prefer to use 'GHC.Core.Make.mkCoreLets' if+-- possible, which does guarantee the invariant+mkLets        :: [Bind b] -> Expr b -> Expr b+-- | Bind all supplied binders over an expression in a nested lambda expression. Prefer to+-- use 'GHC.Core.Make.mkCoreLams' if possible+mkLams        :: [b] -> Expr b -> Expr b++mkLams binders body = foldr Lam body binders+mkLets binds body   = foldr mkLet body binds++mkLet :: Bind b -> Expr b -> Expr b+-- The desugarer sometimes generates an empty Rec group+-- which Lint rejects, so we kill it off right away+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 "GHC.Core#type_let",+-- this can only be used to bind something in a non-recursive @let@ expression+mkTyBind :: TyVar -> Type -> CoreBind+mkTyBind tv ty      = NonRec tv (Type ty)++-- | Create a binding group where a type variable is bound to a type. Per "GHC.Core#type_let",+-- this can only be used to bind something in a non-recursive @let@ expression+mkCoBind :: CoVar -> Coercion -> CoreBind+mkCoBind cv co      = NonRec cv (Coercion co)++-- | Convert a binder into either a 'Var' or 'Type' 'Expr' appropriately+varToCoreExpr :: CoreBndr -> Expr b+varToCoreExpr v | isTyVar v = Type (mkTyVarTy v)+                | isCoVar v = Coercion (mkCoVarCo v)+                | otherwise = ASSERT( isId v ) Var v++varsToCoreExprs :: [CoreBndr] -> [Expr b]+varsToCoreExprs vs = map varToCoreExpr vs++{-+************************************************************************+*                                                                      *+   Getting a result type+*                                                                      *+************************************************************************++These are defined here to avoid a module loop between GHC.Core.Utils and GHC.Core.FVs++-}++applyTypeToArg :: Type -> CoreExpr -> Type+-- ^ Determines the type resulting from applying an expression with given type+-- to a given argument expression+applyTypeToArg fun_ty arg = piResultTy fun_ty (exprToType arg)++-- | If the expression is a 'Type', converts. Otherwise,+-- panics. NB: This does /not/ convert 'Coercion' to 'CoercionTy'.+exprToType :: CoreExpr -> Type+exprToType (Type ty)     = ty+exprToType _bad          = pprPanic "exprToType" empty++-- | If the expression is a 'Coercion', converts.+exprToCoercion_maybe :: CoreExpr -> Maybe Coercion+exprToCoercion_maybe (Coercion co) = Just co+exprToCoercion_maybe _             = Nothing++{-+************************************************************************+*                                                                      *+\subsection{Simple access functions}+*                                                                      *+************************************************************************+-}++-- | Extract every variable by this group+bindersOf  :: Bind b -> [b]+-- If you edit this function, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+bindersOf (NonRec binder _) = [binder]+bindersOf (Rec pairs)       = [binder | (binder, _) <- pairs]++-- | 'bindersOf' applied to a list of binding groups+bindersOfBinds :: [Bind b] -> [b]+bindersOfBinds binds = foldr ((++) . bindersOf) [] binds++rhssOfBind :: Bind b -> [Expr b]+rhssOfBind (NonRec _ rhs) = [rhs]+rhssOfBind (Rec pairs)    = [rhs | (_,rhs) <- pairs]++rhssOfAlts :: [Alt b] -> [Expr b]+rhssOfAlts alts = [e | (_,_,e) <- alts]++-- | Collapse all the bindings in the supplied groups into a single+-- list of lhs\/rhs pairs suitable for binding in a 'Rec' binding group+flattenBinds :: [Bind b] -> [(b, Expr b)]+flattenBinds (NonRec b r : binds) = (b,r) : flattenBinds binds+flattenBinds (Rec prs1   : binds) = prs1 ++ flattenBinds binds+flattenBinds []                   = []++-- | We often want to strip off leading lambdas before getting down to+-- business. Variants are 'collectTyBinders', 'collectValBinders',+-- and 'collectTyAndValBinders'+collectBinders         :: Expr b   -> ([b],     Expr b)+collectTyBinders       :: CoreExpr -> ([TyVar], CoreExpr)+collectValBinders      :: CoreExpr -> ([Id],    CoreExpr)+collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)+-- | Strip off exactly N leading lambdas (type or value). Good for use with+-- join points.+collectNBinders        :: Int -> Expr b -> ([b], Expr b)++collectBinders expr+  = go [] expr+  where+    go bs (Lam b e) = go (b:bs) e+    go bs e          = (reverse bs, e)++collectTyBinders expr+  = go [] expr+  where+    go tvs (Lam b e) | isTyVar b = go (b:tvs) e+    go tvs e                     = (reverse tvs, e)++collectValBinders expr+  = go [] expr+  where+    go ids (Lam b e) | isId b = go (b:ids) e+    go ids body               = (reverse ids, body)++collectTyAndValBinders expr+  = (tvs, ids, body)+  where+    (tvs, body1) = collectTyBinders expr+    (ids, body)  = collectValBinders body1++collectNBinders orig_n orig_expr+  = go orig_n [] orig_expr+  where+    go 0 bs expr      = (reverse bs, expr)+    go n bs (Lam b e) = go (n-1) (b:bs) e+    go _ _  _         = pprPanic "collectNBinders" $ int orig_n++-- | Takes a nested application expression and returns the function+-- being applied and the arguments to which it is applied+collectArgs :: Expr b -> (Expr b, [Arg b])+collectArgs expr+  = go expr []+  where+    go (App f a) as = go f (a:as)+    go e         as = (e, as)++-- | Attempt to remove the last N arguments of a function call.+-- Strip off any ticks or coercions encountered along the way and any+-- at the end.+stripNArgs :: Word -> Expr a -> Maybe (Expr a)+stripNArgs !n (Tick _ e) = stripNArgs n e+stripNArgs n (Cast f _) = stripNArgs n f+stripNArgs 0 e = Just e+stripNArgs n (App f _) = stripNArgs (n - 1) f+stripNArgs _ _ = Nothing++-- | Like @collectArgs@, but also collects looks through floatable+-- ticks if it means that we can find more arguments.+collectArgsTicks :: (Tickish Id -> Bool) -> Expr b+                 -> (Expr b, [Arg b], [Tickish Id])+collectArgsTicks skipTick expr+  = go expr [] []+  where+    go (App f a)  as ts = go f (a:as) ts+    go (Tick t e) as ts+      | skipTick t      = go e as (t:ts)+    go e          as ts = (e, as, reverse ts)+++{-+************************************************************************+*                                                                      *+\subsection{Predicates}+*                                                                      *+************************************************************************++At one time we optionally carried type arguments through to runtime.+@isRuntimeVar v@ returns if (Lam v _) really becomes a lambda at runtime,+i.e. if type applications are actual lambdas because types are kept around+at runtime.  Similarly isRuntimeArg.+-}++-- | Will this variable exist at runtime?+isRuntimeVar :: Var -> Bool+isRuntimeVar = isId++-- | Will this argument expression exist at runtime?+isRuntimeArg :: CoreExpr -> Bool+isRuntimeArg = isValArg++-- | Returns @True@ for value arguments, false for type args+-- NB: coercions are value arguments (zero width, to be sure,+-- like State#, but still value args).+isValArg :: Expr b -> Bool+isValArg e = not (isTypeArg e)++-- | Returns @True@ iff the expression is a 'Type' or 'Coercion'+-- expression at its top level+isTyCoArg :: Expr b -> Bool+isTyCoArg (Type {})     = True+isTyCoArg (Coercion {}) = True+isTyCoArg _             = False++-- | Returns @True@ iff the expression is a 'Coercion'+-- expression at its top level+isCoArg :: Expr b -> Bool+isCoArg (Coercion {}) = True+isCoArg _             = False++-- | Returns @True@ iff the expression is a 'Type' expression at its+-- top level.  Note this does NOT include 'Coercion's.+isTypeArg :: Expr b -> Bool+isTypeArg (Type {}) = True+isTypeArg _         = False++-- | The number of binders that bind values rather than types+valBndrCount :: [CoreBndr] -> Int+valBndrCount = count isId++-- | The number of argument expressions that are values rather than types at their top level+valArgCount :: [Arg b] -> Int+valArgCount = count isValArg++{-+************************************************************************+*                                                                      *+\subsection{Annotated core}+*                                                                      *+************************************************************************+-}++-- | Annotated core: allows annotation at every node in the tree+type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)++-- | A clone of the 'Expr' type but allowing annotation at every tree node+data AnnExpr' bndr annot+  = AnnVar      Id+  | AnnLit      Literal+  | AnnLam      bndr (AnnExpr bndr annot)+  | AnnApp      (AnnExpr bndr annot) (AnnExpr bndr annot)+  | AnnCase     (AnnExpr bndr annot) bndr Type [AnnAlt bndr annot]+  | AnnLet      (AnnBind bndr annot) (AnnExpr bndr annot)+  | AnnCast     (AnnExpr bndr annot) (annot, Coercion)+                   -- Put an annotation on the (root of) the coercion+  | AnnTick     (Tickish Id) (AnnExpr bndr annot)+  | AnnType     Type+  | AnnCoercion Coercion++-- | A clone of the 'Alt' type but allowing annotation at every tree node+type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)++-- | A clone of the 'Bind' type but allowing annotation at every tree node+data AnnBind bndr annot+  = AnnNonRec bndr (AnnExpr bndr annot)+  | AnnRec    [(bndr, AnnExpr bndr annot)]++-- | Takes a nested application expression and returns the function+-- being applied and the arguments to which it is applied+collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])+collectAnnArgs expr+  = go expr []+  where+    go (_, AnnApp f a) as = go f (a:as)+    go e               as = (e, as)++collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a+                       -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])+collectAnnArgsTicks tickishOk expr+  = go expr [] []+  where+    go (_, AnnApp f a)  as ts = go f (a:as) ts+    go (_, AnnTick t e) as ts | tickishOk t+                              = go e as (t:ts)+    go e                as ts = (e, as, reverse ts)++deAnnotate :: AnnExpr bndr annot -> Expr bndr+deAnnotate (_, e) = deAnnotate' e++deAnnotate' :: AnnExpr' bndr annot -> Expr bndr+deAnnotate' (AnnType t)           = Type t+deAnnotate' (AnnCoercion co)      = Coercion co+deAnnotate' (AnnVar  v)           = Var v+deAnnotate' (AnnLit  lit)         = Lit lit+deAnnotate' (AnnLam  binder body) = Lam binder (deAnnotate body)+deAnnotate' (AnnApp  fun arg)     = App (deAnnotate fun) (deAnnotate arg)+deAnnotate' (AnnCast e (_,co))    = Cast (deAnnotate e) co+deAnnotate' (AnnTick tick body)   = Tick tick (deAnnotate body)++deAnnotate' (AnnLet bind body)+  = Let (deAnnBind bind) (deAnnotate body)+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)+collectAnnBndrs e+  = collect [] e+  where+    collect bs (_, AnnLam b body) = collect (b:bs) body+    collect bs body               = (reverse bs, body)++-- | As 'collectNBinders' but for 'AnnExpr' rather than 'Expr'+collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)+collectNAnnBndrs orig_n e+  = collect orig_n [] e+  where+    collect 0 bs body               = (reverse bs, body)+    collect n bs (_, AnnLam b body) = collect (n-1) (b:bs) body+    collect _ _  _                  = pprPanic "collectNBinders" $ int orig_n

+ compiler/GHC/Core/Arity.hs view

@@ -0,0 +1,1211 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+++        Arity and eta expansion+-}++{-# LANGUAGE CPP #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++-- | Arity and eta expansion+module GHC.Core.Arity+   ( manifestArity, joinRhsArity, exprArity, typeArity+   , exprEtaExpandArity, findRhsArity, etaExpand+   , etaExpandToJoinPoint, etaExpandToJoinPointRule+   , exprBotStrictness_maybe+   )+where++#include "HsVersions.h"++import GhcPrelude++import GHC.Core+import GHC.Core.FVs+import GHC.Core.Utils+import GHC.Core.Subst+import Demand+import Var+import VarEnv+import Id+import Type+import TyCon    ( initRecTc, checkRecTc )+import Predicate ( isDictTy )+import Coercion+import BasicTypes+import Unique+import GHC.Driver.Session ( DynFlags, GeneralFlag(..), gopt )+import Outputable+import FastString+import Util     ( debugIsOn )++{-+************************************************************************+*                                                                      *+              manifestArity and exprArity+*                                                                      *+************************************************************************++exprArity is a cheap-and-cheerful version of exprEtaExpandArity.+It tells how many things the expression can be applied to before doing+any work.  It doesn't look inside cases, lets, etc.  The idea is that+exprEtaExpandArity will do the hard work, leaving something that's easy+for exprArity to grapple with.  In particular, Simplify uses exprArity to+compute the ArityInfo for the Id.++Originally I thought that it was enough just to look for top-level lambdas, but+it isn't.  I've seen this++        foo = PrelBase.timesInt++We want foo to get arity 2 even though the eta-expander will leave it+unchanged, in the expectation that it'll be inlined.  But occasionally it+isn't, because foo is blacklisted (used in a rule).++Similarly, see the ok_note check in exprEtaExpandArity.  So+        f = __inline_me (\x -> e)+won't be eta-expanded.++And in any case it seems more robust to have exprArity be a bit more intelligent.+But note that   (\x y z -> f x y z)+should have arity 3, regardless of f's arity.+-}++manifestArity :: CoreExpr -> Arity+-- ^ manifestArity sees how many leading value lambdas there are,+--   after looking through casts+manifestArity (Lam v e) | isId v        = 1 + manifestArity e+                        | otherwise     = manifestArity e+manifestArity (Tick t e) | not (tickishIsCode t) =  manifestArity e+manifestArity (Cast e _)                = manifestArity e+manifestArity _                         = 0++joinRhsArity :: CoreExpr -> JoinArity+-- Join points are supposed to have manifestly-visible+-- lambdas at the top: no ticks, no casts, nothing+-- Moreover, type lambdas count in JoinArity+joinRhsArity (Lam _ e) = 1 + joinRhsArity e+joinRhsArity _         = 0+++---------------+exprArity :: CoreExpr -> Arity+-- ^ An approximate, fast, version of 'exprEtaExpandArity'+exprArity e = go e+  where+    go (Var v)                     = idArity v+    go (Lam x e) | isId x          = go e + 1+                 | otherwise       = go e+    go (Tick t e) | not (tickishIsCode t) = go e+    go (Cast e co)                 = trim_arity (go e) (coercionRKind co)+                                        -- Note [exprArity invariant]+    go (App e (Type _))            = go e+    go (App f a) | exprIsTrivial a = (go f - 1) `max` 0+        -- See Note [exprArity for applications]+        -- NB: coercions count as a value argument++    go _                           = 0++    trim_arity :: Arity -> Type -> Arity+    trim_arity arity ty = arity `min` length (typeArity ty)++---------------+typeArity :: Type -> [OneShotInfo]+-- How many value arrows are visible in the type?+-- We look through foralls, and newtypes+-- See Note [exprArity invariant]+typeArity ty+  = go initRecTc ty+  where+    go rec_nts ty+      | Just (_, ty')  <- splitForAllTy_maybe ty+      = go rec_nts ty'++      | Just (arg,res) <- splitFunTy_maybe ty+      = typeOneShot arg : go rec_nts res++      | Just (tc,tys) <- splitTyConApp_maybe ty+      , Just (ty', _) <- instNewTyCon_maybe tc tys+      , Just rec_nts' <- checkRecTc rec_nts tc  -- See Note [Expanding newtypes]+                                                -- in TyCon+--   , not (isClassTyCon tc)    -- Do not eta-expand through newtype classes+--                              -- See Note [Newtype classes and eta expansion]+--                              (no longer required)+      = go rec_nts' ty'+        -- Important to look through non-recursive newtypes, so that, eg+        --      (f x)   where f has arity 2, f :: Int -> IO ()+        -- Here we want to get arity 1 for the result!+        --+        -- AND through a layer of recursive newtypes+        -- e.g. newtype Stream m a b = Stream (m (Either b (a, Stream m a b)))++      | otherwise+      = []++---------------+exprBotStrictness_maybe :: CoreExpr -> Maybe (Arity, StrictSig)+-- A cheap and cheerful function that identifies bottoming functions+-- and gives them a suitable strictness signatures.  It's used during+-- float-out+exprBotStrictness_maybe e+  = case getBotArity (arityType env e) of+        Nothing -> Nothing+        Just ar -> Just (ar, sig ar)+  where+    env    = AE { ae_ped_bot = True, ae_cheap_fn = \ _ _ -> False }+    sig ar = mkClosedStrictSig (replicate ar topDmd) botDiv++{-+Note [exprArity invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~+exprArity has the following invariants:++  (1) If typeArity (exprType e) = n,+      then manifestArity (etaExpand e n) = n++      That is, etaExpand can always expand as much as typeArity says+      So the case analysis in etaExpand and in typeArity must match++  (2) exprArity e <= typeArity (exprType e)++  (3) Hence if (exprArity e) = n, then manifestArity (etaExpand e n) = n++      That is, if exprArity says "the arity is n" then etaExpand really+      can get "n" manifest lambdas to the top.++Why is this important?  Because+  - In GHC.Iface.Tidy we use exprArity to fix the *final arity* of+    each top-level Id, and in+  - In CorePrep we use etaExpand on each rhs, so that the visible lambdas+    actually match that arity, which in turn means+    that the StgRhs has the right number of lambdas++An alternative would be to do the eta-expansion in GHC.Iface.Tidy, at least+for top-level bindings, in which case we would not need the trim_arity+in exprArity.  That is a less local change, so I'm going to leave it for today!++Note [Newtype classes and eta expansion]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+    NB: this nasty special case is no longer required, because+    for newtype classes we don't use the class-op rule mechanism+    at all.  See Note [Single-method classes] in TcInstDcls. SLPJ May 2013++-------- Old out of date comments, just for interest -----------+We have to be careful when eta-expanding through newtypes.  In general+it's a good idea, but annoyingly it interacts badly with the class-op+rule mechanism.  Consider++   class C a where { op :: a -> a }+   instance C b => C [b] where+     op x = ...++These translate to++   co :: forall a. (a->a) ~ C a++   $copList :: C b -> [b] -> [b]+   $copList d x = ...++   $dfList :: C b -> C [b]+   {-# DFunUnfolding = [$copList] #-}+   $dfList d = $copList d |> co@[b]++Now suppose we have:++   dCInt :: C Int++   blah :: [Int] -> [Int]+   blah = op ($dfList dCInt)++Now we want the built-in op/$dfList rule will fire to give+   blah = $copList dCInt++But with eta-expansion 'blah' might (and in #3772, which is+slightly more complicated, does) turn into++   blah = op (\eta. ($dfList dCInt |> sym co) eta)++and now it is *much* harder for the op/$dfList rule to fire, because+exprIsConApp_maybe won't hold of the argument to op.  I considered+trying to *make* it hold, but it's tricky and I gave up.++The test simplCore/should_compile/T3722 is an excellent example.+-------- End of old out of date comments, just for interest -----------+++Note [exprArity for applications]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we come to an application we check that the arg is trivial.+   eg  f (fac x) does not have arity 2,+                 even if f has arity 3!++* We require that is trivial rather merely cheap.  Suppose f has arity 2.+  Then    f (Just y)+  has arity 0, because if we gave it arity 1 and then inlined f we'd get+          let v = Just y in \w. <f-body>+  which has arity 0.  And we try to maintain the invariant that we don't+  have arity decreases.++*  The `max 0` is important!  (\x y -> f x) has arity 2, even if f is+   unknown, hence arity 0+++************************************************************************+*                                                                      *+           Computing the "arity" of an expression+*                                                                      *+************************************************************************++Note [Definition of arity]+~~~~~~~~~~~~~~~~~~~~~~~~~~+The "arity" of an expression 'e' is n if+   applying 'e' to *fewer* than n *value* arguments+   converges rapidly++Or, to put it another way++   there is no work lost in duplicating the partial+   application (e x1 .. x(n-1))++In the divergent case, no work is lost by duplicating because if the thing+is evaluated once, that's the end of the program.++Or, to put it another way, in any context C++   C[ (\x1 .. xn. e x1 .. xn) ]+         is as efficient as+   C[ e ]++It's all a bit more subtle than it looks:++Note [One-shot lambdas]+~~~~~~~~~~~~~~~~~~~~~~~+Consider one-shot lambdas+                let x = expensive in \y z -> E+We want this to have arity 1 if the \y-abstraction is a 1-shot lambda.++Note [Dealing with bottom]+~~~~~~~~~~~~~~~~~~~~~~~~~~+A Big Deal with computing arities is expressions like++   f = \x -> case x of+               True  -> \s -> e1+               False -> \s -> e2++This happens all the time when f :: Bool -> IO ()+In this case we do eta-expand, in order to get that \s to the+top, and give f arity 2.++This isn't really right in the presence of seq.  Consider+        (f bot) `seq` 1++This should diverge!  But if we eta-expand, it won't.  We ignore this+"problem" (unless -fpedantic-bottoms is on), because being scrupulous+would lose an important transformation for many programs. (See+#5587 for an example.)++Consider also+        f = \x -> error "foo"+Here, arity 1 is fine.  But if it is+        f = \x -> case x of+                        True  -> error "foo"+                        False -> \y -> x+y+then we want to get arity 2.  Technically, this isn't quite right, because+        (f True) `seq` 1+should diverge, but it'll converge if we eta-expand f.  Nevertheless, we+do so; it improves some programs significantly, and increasing convergence+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 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+       case undefined of { (a,b) -> \y -> e }+     This showed up in #5557++ (2) Do NOT move a lambda outside a case if all the branches of+     the case are known to return bottom.+        case x of { (a,b) -> \y -> error "urk" }+     This case is less important, but the idea is that if the fn is+     going to diverge eventually anyway then getting the best arity+     isn't an issue, so we might as well play safe++ (3) Do NOT move a lambda outside a case unless+     (a) The scrutinee is ok-for-speculation, or+     (b) more liberally: the scrutinee is cheap (e.g. a variable), and+         -fpedantic-bottoms is not enforced (see #2915 for an example)++Of course both (1) and (2) are readily defeated by disguising the bottoms.++4. Note [Newtype arity]+~~~~~~~~~~~~~~~~~~~~~~~~+Non-recursive newtypes are transparent, and should not get in the way.+We do (currently) eta-expand recursive newtypes too.  So if we have, say++        newtype T = MkT ([T] -> Int)++Suppose we have+        e = coerce T f+where f has arity 1.  Then: etaExpandArity e = 1;+that is, etaExpandArity looks through the coerce.++When we eta-expand e to arity 1: eta_expand 1 e T+we want to get:                  coerce T (\x::[T] -> (coerce ([T]->Int) e) x)++  HOWEVER, note that if you use coerce bogusly you can ge+        coerce Int negate+  And since negate has arity 2, you might try to eta expand.  But you can't+  decompose Int to a function type.   Hence the final case in eta_expand.++Note [The state-transformer hack]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have+        f = e+where e has arity n.  Then, if we know from the context that f has+a usage type like+        t1 -> ... -> tn -1-> t(n+1) -1-> ... -1-> tm -> ...+then we can expand the arity to m.  This usage type says that+any application (x e1 .. en) will be applied to uniquely to (m-n) more args+Consider f = \x. let y = <expensive>+                 in case x of+                      True  -> foo+                      False -> \(s:RealWorld) -> e+where foo has arity 1.  Then we want the state hack to+apply to foo too, so we can eta expand the case.++Then we expect that if f is applied to one arg, it'll be applied to two+(that's the hack -- we don't really know, and sometimes it's false)+See also Id.isOneShotBndr.++Note [State hack and bottoming functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's a terrible idea to use the state hack on a bottoming function.+Here's what happens (#2861):++  f :: String -> IO T+  f = \p. error "..."++Eta-expand, using the state hack:++  f = \p. (\s. ((error "...") |> g1) s) |> g2+  g1 :: IO T ~ (S -> (S,T))+  g2 :: (S -> (S,T)) ~ IO T++Extrude the g2++  f' = \p. \s. ((error "...") |> g1) s+  f = f' |> (String -> g2)++Discard args for bottomming function++  f' = \p. \s. ((error "...") |> g1 |> g3+  g3 :: (S -> (S,T)) ~ (S,T)++Extrude g1.g3++  f'' = \p. \s. (error "...")+  f' = f'' |> (String -> S -> g1.g3)++And now we can repeat the whole loop.  Aargh!  The bug is in applying the+state hack to a function which then swallows the argument.++This arose in another guise in #3959.  Here we had++     catch# (throw exn >> return ())++Note that (throw :: forall a e. Exn e => e -> a) is called with [a = IO ()].+After inlining (>>) we get++     catch# (\_. throw {IO ()} exn)++We must *not* eta-expand to++     catch# (\_ _. throw {...} exn)++because 'catch#' expects to get a (# _,_ #) after applying its argument to+a State#, not another function!++In short, we use the state hack to allow us to push let inside a lambda,+but not to introduce a new lambda.+++Note [ArityType]+~~~~~~~~~~~~~~~~+ArityType is the result of a compositional analysis on expressions,+from which we can decide the real arity of the expression (extracted+with function exprEtaExpandArity).++Here is what the fields mean. If an arbitrary expression 'f' has+ArityType 'at', then++ * If at = ABot n, then (f x1..xn) definitely diverges. Partial+   applications to fewer than n args may *or may not* diverge.++   We allow ourselves to eta-expand bottoming functions, even+   if doing so may lose some `seq` sharing,+       let x = <expensive> in \y. error (g x y)+       ==> \y. let x = <expensive> in error (g x y)++ * If at = ATop as, and n=length as,+   then expanding 'f' to (\x1..xn. f x1 .. xn) loses no sharing,+   assuming the calls of f respect the one-shot-ness of+   its definition.++   NB 'f' is an arbitrary expression, eg (f = g e1 e2).  This 'f'+   can have ArityType as ATop, with length as > 0, only if e1 e2 are+   themselves.++ * In both cases, f, (f x1), ... (f x1 ... f(n-1)) are definitely+   really functions, or bottom, but *not* casts from a data type, in+   at least one case branch.  (If it's a function in one case branch but+   an unsafe cast from a data type in another, the program is bogus.)+   So eta expansion is dynamically ok; see Note [State hack and+   bottoming functions], the part about catch#++Example:+      f = \x\y. let v = <expensive> in+          \s(one-shot) \t(one-shot). blah+      'f' has ArityType [ManyShot,ManyShot,OneShot,OneShot]+      The one-shot-ness means we can, in effect, push that+      'let' inside the \st.+++Suppose f = \xy. x+y+Then  f             :: AT [False,False] ATop+      f v           :: AT [False]       ATop+      f <expensive> :: AT []            ATop++-------------------- Main arity code ----------------------------+-}++-- See Note [ArityType]+data ArityType = ATop [OneShotInfo] | ABot Arity+     -- 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++-- ^ The Arity returned is the number of value args the+-- expression can be applied to without doing much work+exprEtaExpandArity :: DynFlags -> CoreExpr -> Arity+-- exprEtaExpandArity is used when eta expanding+--      e  ==>  \xy -> e x y+exprEtaExpandArity dflags e+  = case (arityType env e) of+      ATop oss -> length oss+      ABot n   -> n+  where+    env = AE { ae_cheap_fn = mk_cheap_fn dflags isCheapApp+             , ae_ped_bot  = gopt Opt_PedanticBottoms dflags }++getBotArity :: ArityType -> Maybe Arity+-- Arity of a divergent function+getBotArity (ABot n) = Just n+getBotArity _        = Nothing++mk_cheap_fn :: DynFlags -> CheapAppFun -> CheapFun+mk_cheap_fn dflags cheap_app+  | not (gopt Opt_DictsCheap dflags)+  = \e _     -> exprIsCheapX cheap_app e+  | otherwise+  = \e mb_ty -> exprIsCheapX cheap_app e+             || case mb_ty of+                  Nothing -> False+                  Just ty -> isDictTy ty+++----------------------+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 (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, 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 )+#if defined(DEBUG)+                    pprTrace "Exciting arity"+                       (vcat [ ppr bndr <+> ppr cur_arity <+> ppr new_arity+                             , ppr rhs])+#endif+                    go new_info+      where+        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++    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]+~~~~~~~~~~~~~~~~~~~~~+The motivating example for arity analysis is this:++  f = \x. let g = f (x+1)+          in \y. ...g...++What arity does f have?  Really it should have arity 2, but a naive+look at the RHS won't see that.  You need a fixpoint analysis which+says it has arity "infinity" the first time round.++This example happens a lot; it first showed up in Andy Gill's thesis,+fifteen years ago!  It also shows up in the code for 'rnf' on lists+in #4138.++The analysis is easy to achieve because exprEtaExpandArity takes an+argument+     type CheapFun = CoreExpr -> Maybe Type -> Bool+used to decide if an expression is cheap enough to push inside a+lambda.  And exprIsCheapX in turn takes an argument+     type CheapAppFun = Id -> Int -> Bool+which tells when an application is cheap. This makes it easy to+write the analysis loop.++The analysis is cheap-and-cheerful because it doesn't deal with+mutual recursion.  But the self-recursive case is the important one.+++Note [Eta expanding through dictionaries]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If the experimental -fdicts-cheap flag is on, we eta-expand through+dictionary bindings.  This improves arities. Thereby, it also+means that full laziness is less prone to floating out the+application of a function to its dictionary arguments, which+can thereby lose opportunities for fusion.  Example:+        foo :: Ord a => a -> ...+     foo = /\a \(d:Ord a). let d' = ...d... in \(x:a). ....+        -- So foo has arity 1++     f = \x. foo dInt $ bar x++The (foo DInt) is floated out, and makes ineffective a RULE+     foo (bar x) = ...++One could go further and make exprIsCheap reply True to any+dictionary-typed expression, but that's more work.++Note [Eta expanding thunks]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+We don't eta-expand+   * Trivial RHSs     x = y+   * PAPs             x = map g+   * Thunks           f = case y of p -> \x -> blah++When we see+     f = case y of p -> \x -> blah+should we eta-expand it? Well, if 'x' is a one-shot state token+then 'yes' because 'f' will only be applied once.  But otherwise+we (conservatively) say no.  My main reason is to avoid expanding+PAPSs+        f = g d  ==>  f = \x. g d x+because that might in turn make g inline (if it has an inline pragma),+which we might not want.  After all, INLINE pragmas say "inline only+when saturated" so we don't want to be too gung-ho about saturating!+-}++arityLam :: Id -> ArityType -> ArityType+arityLam id (ATop as) = ATop (idStateHackOneShotInfo id : as)+arityLam _  (ABot n)  = ABot (n+1)++floatIn :: Bool -> ArityType -> ArityType+-- We have something like (let x = E in b),+-- where b has the given arity type.+floatIn _     (ABot n)  = ABot n+floatIn True  (ATop as) = ATop as+floatIn False (ATop as) = ATop (takeWhile isOneShotInfo as)+   -- If E is not cheap, keep arity only for one-shots++arityApp :: ArityType -> Bool -> ArityType+-- Processing (fun arg) where at is the ArityType of fun,+-- Knock off an argument and behave like 'let'+arityApp (ABot 0)      _     = ABot 0+arityApp (ABot n)      _     = ABot (n-1)+arityApp (ATop [])     _     = ATop []+arityApp (ATop (_:as)) cheap = floatIn cheap (ATop as)++andArityType :: ArityType -> ArityType -> ArityType   -- Used for branches of a 'case'+andArityType (ABot n1) (ABot n2)  = ABot (n1 `max` n2) -- Note [ABot branches: use max]+andArityType (ATop as)  (ABot _)  = ATop as+andArityType (ABot _)   (ATop bs) = ATop bs+andArityType (ATop as)  (ATop bs) = ATop (as `combine` bs)+  where      -- See Note [Combining case branches]+    combine (a:as) (b:bs) = (a `bestOneShot` b) : combine as bs+    combine []     bs     = takeWhile isOneShotInfo bs+    combine as     []     = takeWhile isOneShotInfo as++{- Note [ABot branches: use max]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider   case x of+             True  -> \x.  error "urk"+             False -> \xy. error "urk2"++Remember: ABot n means "if you apply to n args, it'll definitely diverge".+So we need (ABot 2) for the whole thing, the /max/ of the ABot arities.++Note [Combining case branches]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+  go = \x. let z = go e0+               go2 = \x. case x of+                           True  -> z+                           False -> \s(one-shot). e1+           in go2 x+We *really* want to eta-expand go and go2.+When combining the branches of the case we have+     ATop [] `andAT` ATop [OneShotLam]+and we want to get ATop [OneShotLam].  But if the inner+lambda wasn't one-shot we don't want to do this.+(We need a proper arity analysis to justify that.)++So we combine the best of the two branches, on the (slightly dodgy)+basis that if we know one branch is one-shot, then they all must be.++Note [Arity trimming]+~~~~~~~~~~~~~~~~~~~~~+Consider ((\x y. blah) |> co), where co :: (Int->Int->Int) ~ (Int -> F a) , and+F is some type family.++Because of Note [exprArity invariant], item (2), we must return with arity at+most 1, because typeArity (Int -> F a) = 1.  So we have to trim the result of+calling arityType on (\x y. blah).  Failing to do so, and hence breaking the+exprArity invariant, led to #5441.++How to trim?  For ATop, it's easy.  But we must take great care with ABot.+Suppose the expression was (\x y. error "urk"), we'll get (ABot 2).  We+absolutely must not trim that to (ABot 1), because that claims that+((\x y. error "urk") |> co) diverges when given one argument, which it+absolutely does not. And Bad Things happen if we think something returns bottom+when it doesn't (#16066).++So, do not reduce the 'n' in (ABot n); rather, switch (conservatively) to ATop.++Historical note: long ago, we unconditionally switched to ATop when we+encountered a cast, but that is far too conservative: see #5475+-}++---------------------------+type CheapFun = CoreExpr -> Maybe Type -> Bool+        -- How to decide if an expression is cheap+        -- If the Maybe is Just, the type is the type+        -- of the expression; Nothing means "don't know"++data ArityEnv+  = AE { ae_cheap_fn :: CheapFun+       , ae_ped_bot  :: Bool       -- True <=> be pedantic about bottoms+  }++arityType :: ArityEnv -> CoreExpr -> ArityType++arityType env (Cast e co)+  = case arityType env e of+      ATop os -> ATop (take co_arity os)+      -- See Note [Arity trimming]+      ABot n | co_arity < n -> ATop (replicate co_arity noOneShotInfo)+             | otherwise    -> ABot n+  where+    co_arity = length (typeArity (coercionRKind co))+    -- See Note [exprArity invariant] (2); must be true of+    -- arityType too, since that is how we compute the arity+    -- of variables, and they in turn affect result of exprArity+    -- #5441 is a nice demo+    -- However, do make sure that ATop -> ATop and ABot -> ABot!+    --   Casts don't affect that part. Getting this wrong provoked #5475++arityType _ (Var v)+  | strict_sig <- idStrictness v+  , not $ isTopSig strict_sig+  , (ds, res) <- splitStrictSig strict_sig+  , let arity = length ds+  = if isBotDiv res then ABot arity+                    else ATop (take arity one_shots)+  | otherwise+  = ATop (take (idArity v) one_shots)+  where+    one_shots :: [OneShotInfo]  -- One-shot-ness derived from the type+    one_shots = typeArity (idType v)++        -- Lambdas; increase arity+arityType env (Lam x e)+  | isId x    = arityLam x (arityType env e)+  | otherwise = arityType env e++        -- Applications; decrease arity, except for types+arityType env (App fun (Type _))+   = arityType env fun+arityType env (App fun arg )+   = arityApp (arityType env fun) (ae_cheap_fn env arg Nothing)++        -- Case/Let; keep arity if either the expression is cheap+        -- or it's a 1-shot lambda+        -- The former is not really right for Haskell+        --      f x = case x of { (a,b) -> \y. e }+        --  ===>+        --      f x y = case x of { (a,b) -> e }+        -- The difference is observable using 'seq'+        --+arityType env (Case scrut _ _ alts)+  | exprIsBottom scrut || null alts+  = ABot 0     -- Do not eta expand+               -- See Note [Dealing with bottom (1)]+  | otherwise+  = case alts_type of+     ABot n  | n>0       -> ATop []    -- Don't eta expand+             | otherwise -> ABot 0     -- if RHS is bottomming+                                       -- See Note [Dealing with bottom (2)]++     ATop as | not (ae_ped_bot env)    -- See Note [Dealing with bottom (3)]+             , ae_cheap_fn env scrut Nothing -> ATop as+             | exprOkForSpeculation scrut    -> ATop as+             | otherwise                     -> ATop (takeWhile isOneShotInfo as)+  where+    alts_type = foldr1 andArityType [arityType env rhs | (_,_,rhs) <- alts]++arityType env (Let b e)+  = floatIn (cheap_bind b) (arityType env e)+  where+    cheap_bind (NonRec b e) = is_cheap (b,e)+    cheap_bind (Rec prs)    = all is_cheap prs+    is_cheap (b,e) = ae_cheap_fn env e (Just (idType b))++arityType env (Tick t e)+  | not (tickishIsCode t)     = arityType env e++arityType _ _ = vanillaArityType++{-+%************************************************************************+%*                                                                      *+              The main eta-expander+%*                                                                      *+%************************************************************************++We go for:+   f = \x1..xn -> N  ==>   f = \x1..xn y1..ym -> N y1..ym+                                 (n >= 0)++where (in both cases)++        * The xi can include type variables++        * The yi are all value variables++        * N is a NORMAL FORM (i.e. no redexes anywhere)+          wanting a suitable number of extra args.++The biggest reason for doing this is for cases like++        f = \x -> case x of+                    True  -> \y -> e1+                    False -> \y -> e2++Here we want to get the lambdas together.  A good example is the nofib+program fibheaps, which gets 25% more allocation if you don't do this+eta-expansion.++We may have to sandwich some coerces between the lambdas+to make the types work.   exprEtaExpandArity looks through coerces+when computing arity; and etaExpand adds the coerces as necessary when+actually computing the expansion.++Note [No crap in eta-expanded code]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The eta expander is careful not to introduce "crap".  In particular,+given a CoreExpr satisfying the 'CpeRhs' invariant (in CorePrep), it+returns a CoreExpr satisfying the same invariant. See Note [Eta+expansion and the CorePrep invariants] in CorePrep.++This means the eta-expander has to do a bit of on-the-fly+simplification but it's not too hard.  The alternative, of relying on+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 abandoning 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+        etaExpand 2 (\x -> scc "foo" e)+        = (\xy -> (scc "foo" e) y)+So the costs of evaluating 'e' (not 'e y') are attributed to "foo"++Note [Eta expansion and source notes]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+CorePrep puts floatable ticks outside of value applications, but not+type applications. As a result we might be trying to eta-expand an+expression like++  (src<...> v) @a++which we want to lead to code like++  \x -> src<...> v @a x++This means that we need to look through type applications and be ready+to re-add floats on the top.++-}++-- | @etaExpand n e@ returns an expression with+-- the same meaning as @e@, but with arity @n@.+--+-- Given:+--+-- > e' = etaExpand n e+--+-- We should have that:+--+-- > ty = exprType e = exprType e'+etaExpand :: Arity              -- ^ Result should have this number of value args+          -> CoreExpr           -- ^ Expression to expand+          -> CoreExpr+-- etaExpand arity e = res+-- Then 'res' has at least 'arity' lambdas at the top+--+-- etaExpand deals with for-alls. For example:+--              etaExpand 1 E+-- where  E :: forall a. a -> a+-- would return+--      (/\b. \y::a -> E b y)+--+-- It deals with coerces too, though they are now rare+-- so perhaps the extra code isn't worth it++etaExpand n orig_expr+  = go n orig_expr+  where+      -- Strip off existing lambdas and casts before handing off to mkEtaWW+      -- Note [Eta expansion and SCCs]+    go 0 expr = expr+    go n (Lam v body) | isTyVar v = Lam v (go n     body)+                      | otherwise = Lam v (go (n-1) body)+    go n (Cast expr co)           = Cast (go n expr) co+    go n expr+      = -- pprTrace "ee" (vcat [ppr orig_expr, ppr expr, ppr etas]) $+        retick $ etaInfoAbs etas (etaInfoApp subst' sexpr etas)+      where+          in_scope = mkInScopeSet (exprFreeVars expr)+          (in_scope', etas) = mkEtaWW n (ppr orig_expr) in_scope (exprType expr)+          subst' = mkEmptySubst in_scope'++          -- Find ticks behind type apps.+          -- See Note [Eta expansion and source notes]+          (expr', args) = collectArgs expr+          (ticks, expr'') = stripTicksTop tickishFloatable expr'+          sexpr = foldl' App expr'' args+          retick expr = foldr mkTick expr ticks++                                -- Abstraction    Application+--------------+data EtaInfo = EtaVar Var       -- /\a. []        [] a+                                -- \x.  []        [] x+             | EtaCo Coercion   -- [] |> sym co   [] |> co++instance Outputable EtaInfo where+   ppr (EtaVar v) = text "EtaVar" <+> ppr v+   ppr (EtaCo co) = text "EtaCo"  <+> ppr co++pushCoercion :: Coercion -> [EtaInfo] -> [EtaInfo]+pushCoercion co1 (EtaCo co2 : eis)+  | isReflCo co = eis+  | otherwise   = EtaCo co : eis+  where+    co = co1 `mkTransCo` co2++pushCoercion co eis = EtaCo co : eis++--------------+etaInfoAbs :: [EtaInfo] -> CoreExpr -> CoreExpr+etaInfoAbs []               expr = expr+etaInfoAbs (EtaVar v : eis) expr = Lam v (etaInfoAbs eis expr)+etaInfoAbs (EtaCo co : eis) expr = Cast (etaInfoAbs eis expr) (mkSymCo co)++--------------+etaInfoApp :: Subst -> CoreExpr -> [EtaInfo] -> CoreExpr+-- (etaInfoApp s e eis) returns something equivalent to+--             ((substExpr s e) `appliedto` eis)++etaInfoApp subst (Lam v1 e) (EtaVar v2 : eis)+  = etaInfoApp (GHC.Core.Subst.extendSubstWithVar subst v1 v2) e eis++etaInfoApp subst (Cast e co1) eis+  = etaInfoApp subst e (pushCoercion co' eis)+  where+    co' = GHC.Core.Subst.substCo subst co1++etaInfoApp subst (Case e b ty alts) eis+  = Case (subst_expr subst e) b1 ty' alts'+  where+    (subst1, b1) = substBndr subst b+    alts' = map subst_alt alts+    ty'   = etaInfoAppTy (GHC.Core.Subst.substTy subst ty) eis+    subst_alt (con, bs, rhs) = (con, bs', etaInfoApp subst2 rhs eis)+              where+                 (subst2,bs') = substBndrs subst1 bs++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') = substBindSC subst b++etaInfoApp subst (Tick t e) eis+  = Tick (substTickish subst t) (etaInfoApp subst e eis)++etaInfoApp subst expr _+  | (Var fun, _) <- collectArgs expr+  , Var fun' <- lookupIdSubst (text "etaInfoApp" <+> ppr fun) subst fun+  , isJoinId fun'+  = subst_expr subst expr++etaInfoApp subst e eis+  = go (subst_expr subst e) eis+  where+    go e []                  = e+    go e (EtaVar v    : eis) = go (App e (varToCoreExpr v)) eis+    go e (EtaCo co    : eis) = go (Cast e co) eis+++--------------+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 (coercionRKind co) eis++--------------+-- | @mkEtaWW n _ fvs ty@ will compute the 'EtaInfo' necessary for eta-expanding+-- an expression @e :: ty@ to take @n@ value arguments, where @fvs@ are the+-- free variables of @e@.+--+-- Note that this function is entirely unconcerned about cost centres and other+-- semantically-irrelevant source annotations, so call sites must take care to+-- preserve that info. See Note [Eta expansion and SCCs].+mkEtaWW+  :: Arity+  -- ^ How many value arguments to eta-expand+  -> SDoc+  -- ^ The pretty-printed original expression, for warnings.+  -> InScopeSet+  -- ^ A super-set of the free vars of the expression to eta-expand.+  -> Type+  -> (InScopeSet, [EtaInfo])+  -- ^ The variables in 'EtaInfo' are fresh wrt. to the incoming 'InScopeSet'.+  -- The outgoing 'InScopeSet' extends the incoming 'InScopeSet' with the+  -- fresh variables in 'EtaInfo'.++mkEtaWW orig_n ppr_orig_expr in_scope orig_ty+  = go orig_n empty_subst orig_ty []+  where+    empty_subst = mkEmptyTCvSubst in_scope++    go :: Arity              -- Number of value args to expand to+       -> TCvSubst -> Type   -- We are really looking at subst(ty)+       -> [EtaInfo]          -- Accumulating parameter+       -> (InScopeSet, [EtaInfo])+    go n subst ty eis       -- See Note [exprArity invariant]++       ----------- Done!  No more expansion needed+       | n == 0+       = (getTCvInScope subst, reverse eis)++       ----------- Forall types  (forall a. ty)+       | Just (tcv,ty') <- splitForAllTy_maybe ty+       , let (subst', tcv') = Type.substVarBndr subst tcv+       = let ((n_subst, n_tcv), n_n)+               -- We want to have at least 'n' lambdas at the top.+               -- If tcv is a tyvar, it corresponds to one Lambda (/\).+               --   And we won't reduce n.+               -- If tcv is a covar, we could eta-expand the expr with one+               --   lambda \co:ty. e co. In this case we generate a new variable+               --   of the coercion type, update the scope, and reduce n by 1.+               | isTyVar tcv = ((subst', tcv'), n)+               | otherwise   = (freshEtaId n subst' (varType tcv'), n-1)+           -- Avoid free vars of the original expression+         in go n_n n_subst ty' (EtaVar n_tcv : eis)++       ----------- Function types  (t1 -> t2)+       | Just (arg_ty, res_ty) <- splitFunTy_maybe ty+       , not (isTypeLevPoly arg_ty)+          -- See Note [Levity polymorphism invariants] in GHC.Core+          -- See also test case typecheck/should_run/EtaExpandLevPoly++       , let (subst', eta_id') = freshEtaId n subst arg_ty+           -- Avoid free vars of the original expression+       = go (n-1) subst' res_ty (EtaVar eta_id' : eis)++       ----------- Newtypes+       -- Given this:+       --      newtype T = MkT ([T] -> Int)+       -- Consider eta-expanding this+       --      eta_expand 1 e T+       -- We want to get+       --      coerce T (\x::[T] -> (coerce ([T]->Int) e) x)+       | Just (co, ty') <- topNormaliseNewType_maybe ty+       , let co' = Coercion.substCo subst co+             -- Remember to apply the substitution to co (#16979)+             -- (or we could have applied to ty, but then+             --  we'd have had to zap it for the recursive call)+       = 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+                         -- is levity-polymorphic+       = WARN( True, (ppr orig_n <+> ppr orig_ty) $$ ppr_orig_expr )+         (getTCvInScope subst, reverse eis)+        -- This *can* legitimately happen:+        -- e.g.  coerce Int (\x. x) Essentially the programmer is+        -- playing fast and loose with types (Happy does this a lot).+        -- So we simply decline to eta-expand.  Otherwise we'd end up+        -- with an explicit lambda having a non-function type++++--------------+-- Don't use short-cutting substitution - we may be changing the types of join+-- points, so applying the in-scope set is necessary+-- TODO Check if we actually *are* changing any join points' types++subst_expr :: Subst -> CoreExpr -> CoreExpr+subst_expr = substExpr (text "GHC.Core.Arity:substExpr")+++--------------++-- | Split an expression into the given number of binders and a body,+-- eta-expanding if necessary. Counts value *and* type binders.+etaExpandToJoinPoint :: JoinArity -> CoreExpr -> ([CoreBndr], CoreExpr)+etaExpandToJoinPoint join_arity expr+  = go join_arity [] expr+  where+    go 0 rev_bs e         = (reverse rev_bs, e)+    go n rev_bs (Lam b e) = go (n-1) (b : rev_bs) e+    go n rev_bs e         = case etaBodyForJoinPoint n e of+                              (bs, e') -> (reverse rev_bs ++ bs, e')++etaExpandToJoinPointRule :: JoinArity -> CoreRule -> CoreRule+etaExpandToJoinPointRule _ rule@(BuiltinRule {})+  = WARN(True, (sep [text "Can't eta-expand built-in rule:", ppr rule]))+      -- How did a local binding get a built-in rule anyway? Probably a plugin.+    rule+etaExpandToJoinPointRule join_arity rule@(Rule { ru_bndrs = bndrs, ru_rhs = rhs+                                               , ru_args  = args })+  | need_args == 0+  = rule+  | need_args < 0+  = pprPanic "etaExpandToJoinPointRule" (ppr join_arity $$ ppr rule)+  | otherwise+  = rule { ru_bndrs = bndrs ++ new_bndrs, ru_args = args ++ new_args+         , ru_rhs = new_rhs }+  where+    need_args = join_arity - length args+    (new_bndrs, new_rhs) = etaBodyForJoinPoint need_args rhs+    new_args = varsToCoreExprs new_bndrs++-- Adds as many binders as asked for; assumes expr is not a lambda+etaBodyForJoinPoint :: Int -> CoreExpr -> ([CoreBndr], CoreExpr)+etaBodyForJoinPoint need_args body+  = go need_args (exprType body) (init_subst body) [] body+  where+    go 0 _  _     rev_bs e+      = (reverse rev_bs, e)+    go n ty subst rev_bs e+      | Just (tv, res_ty) <- splitForAllTy_maybe ty+      , let (subst', tv') = Type.substVarBndr subst tv+      = go (n-1) res_ty subst' (tv' : rev_bs) (e `App` varToCoreExpr tv')+      | Just (arg_ty, res_ty) <- splitFunTy_maybe ty+      , let (subst', b) = freshEtaId n subst arg_ty+      = go (n-1) res_ty subst' (b : rev_bs) (e `App` Var b)+      | otherwise+      = pprPanic "etaBodyForJoinPoint" $ int need_args $$+                                         ppr body $$ ppr (exprType body)++    init_subst e = mkEmptyTCvSubst (mkInScopeSet (exprFreeVars e))++--------------+freshEtaId :: Int -> TCvSubst -> Type -> (TCvSubst, Id)+-- Make a fresh Id, with specified type (after applying substitution)+-- It should be "fresh" in the sense that it's not in the in-scope set+-- of the TvSubstEnv; and it should itself then be added to the in-scope+-- set of the TvSubstEnv+--+-- The Int is just a reasonable starting point for generating a unique;+-- it does not necessarily have to be unique itself.+freshEtaId n subst ty+      = (subst', eta_id')+      where+        ty'     = Type.substTyUnchecked subst ty+        eta_id' = uniqAway (getTCvInScope subst) $+                  mkSysLocalOrCoVar (fsLit "eta") (mkBuiltinUnique n) ty'+                  -- "OrCoVar" since this can be used to eta-expand+                  -- coercion abstractions+        subst'  = extendTCvInScope subst eta_id'

+ compiler/GHC/Core/FVs.hs view

@@ -0,0 +1,777 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++Taken quite directly from the Peyton Jones/Lester paper.+-}++{-# LANGUAGE CPP #-}++-- | A module concerned with finding the free variables of an expression.+module GHC.Core.FVs (+        -- * Free variables of expressions and binding groups+        exprFreeVars,+        exprFreeVarsDSet,+        exprFreeVarsList,+        exprFreeIds,+        exprFreeIdsDSet,+        exprFreeIdsList,+        exprsFreeIdsDSet,+        exprsFreeIdsList,+        exprsFreeVars,+        exprsFreeVarsList,+        bindFreeVars,++        -- * Selective free variables of expressions+        InterestingVarFun,+        exprSomeFreeVars, exprsSomeFreeVars,+        exprSomeFreeVarsList, exprsSomeFreeVarsList,++        -- * Free variables of Rules, Vars and Ids+        varTypeTyCoVars,+        varTypeTyCoFVs,+        idUnfoldingVars, idFreeVars, dIdFreeVars,+        bndrRuleAndUnfoldingVarsDSet,+        idFVs,+        idRuleVars, idRuleRhsVars, stableUnfoldingVars,+        ruleRhsFreeVars, ruleFreeVars, rulesFreeVars,+        rulesFreeVarsDSet,+        ruleLhsFreeIds, ruleLhsFreeIdsList,++        expr_fvs,++        -- * Orphan names+        orphNamesOfType, orphNamesOfCo, orphNamesOfAxiom,+        orphNamesOfTypes, orphNamesOfCoCon,+        exprsOrphNames, orphNamesOfFamInst,++        -- * Core syntax tree annotation with free variables+        FVAnn,                  -- annotation, abstract+        CoreExprWithFVs,        -- = AnnExpr Id FVAnn+        CoreExprWithFVs',       -- = AnnExpr' Id FVAnn+        CoreBindWithFVs,        -- = AnnBind Id FVAnn+        CoreAltWithFVs,         -- = AnnAlt Id FVAnn+        freeVars,               -- CoreExpr -> CoreExprWithFVs+        freeVarsBind,           -- CoreBind -> DVarSet -> (DVarSet, CoreBindWithFVs)+        freeVarsOf,             -- CoreExprWithFVs -> DIdSet+        freeVarsOfAnn+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Core+import Id+import IdInfo+import NameSet+import UniqSet+import Unique (Uniquable (..))+import Name+import VarSet+import Var+import Type+import TyCoRep+import TyCoFVs+import TyCon+import CoAxiom+import FamInstEnv+import TysPrim( funTyConName )+import Maybes( orElse )+import Util+import BasicTypes( Activation )+import Outputable+import FV++{-+************************************************************************+*                                                                      *+\section{Finding the free variables of an expression}+*                                                                      *+************************************************************************++This function simply finds the free variables of an expression.+So far as type variables are concerned, it only finds tyvars that are++        * free in type arguments,+        * free in the type of a binder,++but not those that are free in the type of variable occurrence.+-}++-- | Find all locally-defined free Ids or type variables in an expression+-- returning a non-deterministic set.+exprFreeVars :: CoreExpr -> VarSet+exprFreeVars = fvVarSet . exprFVs++-- | Find all locally-defined free Ids or type variables in an expression+-- returning a composable FV computation. See Note [FV naming conventions] in FV+-- for why export it.+exprFVs :: CoreExpr -> FV+exprFVs = filterFV isLocalVar . expr_fvs++-- | Find all locally-defined free Ids or type variables in an expression+-- returning a deterministic set.+exprFreeVarsDSet :: CoreExpr -> DVarSet+exprFreeVarsDSet = fvDVarSet . exprFVs++-- | Find all locally-defined free Ids or type variables in an expression+-- returning a deterministically ordered list.+exprFreeVarsList :: CoreExpr -> [Var]+exprFreeVarsList = fvVarList . exprFVs++-- | Find all locally-defined free Ids in an expression+exprFreeIds :: CoreExpr -> IdSet        -- Find all locally-defined free Ids+exprFreeIds = exprSomeFreeVars isLocalId++-- | Find all locally-defined free Ids in an expression+-- returning a deterministic set.+exprFreeIdsDSet :: CoreExpr -> DIdSet -- Find all locally-defined free Ids+exprFreeIdsDSet = exprSomeFreeVarsDSet isLocalId++-- | Find all locally-defined free Ids in an expression+-- returning a deterministically ordered list.+exprFreeIdsList :: CoreExpr -> [Id] -- Find all locally-defined free Ids+exprFreeIdsList = exprSomeFreeVarsList isLocalId++-- | Find all locally-defined free Ids in several expressions+-- returning a deterministic set.+exprsFreeIdsDSet :: [CoreExpr] -> DIdSet -- Find all locally-defined free Ids+exprsFreeIdsDSet = exprsSomeFreeVarsDSet isLocalId++-- | Find all locally-defined free Ids in several expressions+-- returning a deterministically ordered list.+exprsFreeIdsList :: [CoreExpr] -> [Id]   -- Find all locally-defined free Ids+exprsFreeIdsList = exprsSomeFreeVarsList isLocalId++-- | Find all locally-defined free Ids or type variables in several expressions+-- returning a non-deterministic set.+exprsFreeVars :: [CoreExpr] -> VarSet+exprsFreeVars = fvVarSet . exprsFVs++-- | Find all locally-defined free Ids or type variables in several expressions+-- returning a composable FV computation. See Note [FV naming conventions] in FV+-- for why export it.+exprsFVs :: [CoreExpr] -> FV+exprsFVs exprs = mapUnionFV exprFVs exprs++-- | Find all locally-defined free Ids or type variables in several expressions+-- returning a deterministically ordered list.+exprsFreeVarsList :: [CoreExpr] -> [Var]+exprsFreeVarsList = fvVarList . exprsFVs++-- | Find all locally defined free Ids in a binding group+bindFreeVars :: CoreBind -> VarSet+bindFreeVars (NonRec b r) = fvVarSet $ filterFV isLocalVar $ rhs_fvs (b,r)+bindFreeVars (Rec prs)    = fvVarSet $ filterFV isLocalVar $+                                addBndrs (map fst prs)+                                     (mapUnionFV rhs_fvs prs)++-- | Finds free variables in an expression selected by a predicate+exprSomeFreeVars :: InterestingVarFun   -- ^ Says which 'Var's are interesting+                 -> CoreExpr+                 -> VarSet+exprSomeFreeVars fv_cand e = fvVarSet $ filterFV fv_cand $ expr_fvs e++-- | Finds free variables in an expression selected by a predicate+-- returning a deterministically ordered list.+exprSomeFreeVarsList :: InterestingVarFun -- ^ Says which 'Var's are interesting+                     -> CoreExpr+                     -> [Var]+exprSomeFreeVarsList fv_cand e = fvVarList $ filterFV fv_cand $ expr_fvs e++-- | Finds free variables in an expression selected by a predicate+-- returning a deterministic set.+exprSomeFreeVarsDSet :: InterestingVarFun -- ^ Says which 'Var's are interesting+                     -> CoreExpr+                     -> DVarSet+exprSomeFreeVarsDSet fv_cand e = fvDVarSet $ filterFV fv_cand $ expr_fvs e++-- | Finds free variables in several expressions selected by a predicate+exprsSomeFreeVars :: InterestingVarFun  -- Says which 'Var's are interesting+                  -> [CoreExpr]+                  -> VarSet+exprsSomeFreeVars fv_cand es =+  fvVarSet $ filterFV fv_cand $ mapUnionFV expr_fvs es++-- | Finds free variables in several expressions selected by a predicate+-- returning a deterministically ordered list.+exprsSomeFreeVarsList :: InterestingVarFun  -- Says which 'Var's are interesting+                      -> [CoreExpr]+                      -> [Var]+exprsSomeFreeVarsList fv_cand es =+  fvVarList $ filterFV fv_cand $ mapUnionFV expr_fvs es++-- | Finds free variables in several expressions selected by a predicate+-- returning a deterministic set.+exprsSomeFreeVarsDSet :: InterestingVarFun -- ^ Says which 'Var's are interesting+                      -> [CoreExpr]+                      -> DVarSet+exprsSomeFreeVarsDSet fv_cand e =+  fvDVarSet $ filterFV fv_cand $ mapUnionFV expr_fvs e++--      Comment about obsolete code+-- We used to gather the free variables the RULES at a variable occurrence+-- with the following cryptic comment:+--     "At a variable occurrence, add in any free variables of its rule rhss+--     Curiously, we gather the Id's free *type* variables from its binding+--     site, but its free *rule-rhs* variables from its usage sites.  This+--     is a little weird.  The reason is that the former is more efficient,+--     but the latter is more fine grained, and a makes a difference when+--     a variable mentions itself one of its own rule RHSs"+-- Not only is this "weird", but it's also pretty bad because it can make+-- a function seem more recursive than it is.  Suppose+--      f  = ...g...+--      g  = ...+--         RULE g x = ...f...+-- Then f is not mentioned in its own RHS, and needn't be a loop breaker+-- (though g may be).  But if we collect the rule fvs from g's occurrence,+-- it looks as if f mentions itself.  (This bites in the eftInt/eftIntFB+-- code in GHC.Enum.)+--+-- Anyway, it seems plain wrong.  The RULE is like an extra RHS for the+-- function, so its free variables belong at the definition site.+--+-- Deleted code looked like+--     foldVarSet add_rule_var var_itself_set (idRuleVars var)+--     add_rule_var var set | keep_it fv_cand in_scope var = extendVarSet set var+--                          | otherwise                    = set+--      SLPJ Feb06++addBndr :: CoreBndr -> FV -> FV+addBndr bndr fv fv_cand in_scope acc+  = (varTypeTyCoFVs bndr `unionFV`+        -- Include type variables in the binder's type+        --      (not just Ids; coercion variables too!)+     FV.delFV bndr fv) fv_cand in_scope acc++addBndrs :: [CoreBndr] -> FV -> FV+addBndrs bndrs fv = foldr addBndr fv bndrs++expr_fvs :: CoreExpr -> FV+expr_fvs (Type ty) fv_cand in_scope acc =+  tyCoFVsOfType ty fv_cand in_scope acc+expr_fvs (Coercion co) fv_cand in_scope acc =+  tyCoFVsOfCo co fv_cand in_scope acc+expr_fvs (Var var) fv_cand in_scope acc = FV.unitFV var fv_cand in_scope acc+expr_fvs (Lit _) fv_cand in_scope acc = emptyFV fv_cand in_scope acc+expr_fvs (Tick t expr) fv_cand in_scope acc =+  (tickish_fvs t `unionFV` expr_fvs expr) fv_cand in_scope acc+expr_fvs (App fun arg) fv_cand in_scope acc =+  (expr_fvs fun `unionFV` expr_fvs arg) fv_cand in_scope acc+expr_fvs (Lam bndr body) fv_cand in_scope acc =+  addBndr bndr (expr_fvs body) fv_cand in_scope acc+expr_fvs (Cast expr co) fv_cand in_scope acc =+  (expr_fvs expr `unionFV` tyCoFVsOfCo co) fv_cand in_scope acc++expr_fvs (Case scrut bndr ty alts) fv_cand in_scope acc+  = (expr_fvs scrut `unionFV` tyCoFVsOfType ty `unionFV` addBndr bndr+      (mapUnionFV alt_fvs alts)) fv_cand in_scope acc+  where+    alt_fvs (_, bndrs, rhs) = addBndrs bndrs (expr_fvs rhs)++expr_fvs (Let (NonRec bndr rhs) body) fv_cand in_scope acc+  = (rhs_fvs (bndr, rhs) `unionFV` addBndr bndr (expr_fvs body))+      fv_cand in_scope acc++expr_fvs (Let (Rec pairs) body) fv_cand in_scope acc+  = addBndrs (map fst pairs)+             (mapUnionFV rhs_fvs pairs `unionFV` expr_fvs body)+               fv_cand in_scope acc++---------+rhs_fvs :: (Id, CoreExpr) -> FV+rhs_fvs (bndr, rhs) = expr_fvs rhs `unionFV`+                      bndrRuleAndUnfoldingFVs bndr+        -- Treat any RULES as extra RHSs of the binding++---------+exprs_fvs :: [CoreExpr] -> FV+exprs_fvs exprs = mapUnionFV expr_fvs exprs++tickish_fvs :: Tickish Id -> FV+tickish_fvs (Breakpoint _ ids) = FV.mkFVs ids+tickish_fvs _ = emptyFV++{-+************************************************************************+*                                                                      *+\section{Free names}+*                                                                      *+************************************************************************+-}++-- | Finds the free /external/ names of an expression, notably+-- including the names of type constructors (which of course do not show+-- up in 'exprFreeVars').+exprOrphNames :: CoreExpr -> NameSet+-- There's no need to delete local binders, because they will all+-- be /internal/ names.+exprOrphNames e+  = go e+  where+    go (Var v)+      | isExternalName n    = unitNameSet n+      | otherwise           = emptyNameSet+      where n = idName v+    go (Lit _)              = emptyNameSet+    go (Type ty)            = orphNamesOfType ty        -- Don't need free tyvars+    go (Coercion co)        = orphNamesOfCo co+    go (App e1 e2)          = go e1 `unionNameSet` go e2+    go (Lam v e)            = go e `delFromNameSet` idName v+    go (Tick _ e)           = go e+    go (Cast e co)          = go e `unionNameSet` orphNamesOfCo co+    go (Let (NonRec _ r) e) = go e `unionNameSet` go r+    go (Let (Rec prs) e)    = exprsOrphNames (map snd prs) `unionNameSet` go e+    go (Case e _ ty as)     = go e `unionNameSet` orphNamesOfType ty+                              `unionNameSet` unionNameSets (map go_alt as)++    go_alt (_,_,r) = go r++-- | Finds the free /external/ names of several expressions: see 'exprOrphNames' for details+exprsOrphNames :: [CoreExpr] -> NameSet+exprsOrphNames es = foldr (unionNameSet . exprOrphNames) emptyNameSet es+++{- **********************************************************************+%*                                                                      *+                    orphNamesXXX++%*                                                                      *+%********************************************************************* -}++orphNamesOfTyCon :: TyCon -> NameSet+orphNamesOfTyCon tycon = unitNameSet (getName tycon) `unionNameSet` case tyConClass_maybe tycon of+    Nothing  -> emptyNameSet+    Just cls -> unitNameSet (getName cls)++orphNamesOfType :: Type -> NameSet+orphNamesOfType ty | Just ty' <- coreView ty = orphNamesOfType ty'+                -- Look through type synonyms (#4912)+orphNamesOfType (TyVarTy _)          = emptyNameSet+orphNamesOfType (LitTy {})           = emptyNameSet+orphNamesOfType (TyConApp tycon tys) = orphNamesOfTyCon tycon+                                       `unionNameSet` orphNamesOfTypes tys+orphNamesOfType (ForAllTy bndr res)  = orphNamesOfType (binderType bndr)+                                       `unionNameSet` orphNamesOfType res+orphNamesOfType (FunTy _ arg res)    = unitNameSet funTyConName    -- NB!  See #8535+                                       `unionNameSet` orphNamesOfType arg+                                       `unionNameSet` orphNamesOfType res+orphNamesOfType (AppTy fun arg)      = orphNamesOfType fun `unionNameSet` orphNamesOfType arg+orphNamesOfType (CastTy ty co)       = orphNamesOfType ty `unionNameSet` orphNamesOfCo co+orphNamesOfType (CoercionTy co)      = orphNamesOfCo co++orphNamesOfThings :: (a -> NameSet) -> [a] -> NameSet+orphNamesOfThings f = foldr (unionNameSet . f) emptyNameSet++orphNamesOfTypes :: [Type] -> NameSet+orphNamesOfTypes = orphNamesOfThings orphNamesOfType++orphNamesOfMCo :: MCoercion -> NameSet+orphNamesOfMCo MRefl    = emptyNameSet+orphNamesOfMCo (MCo co) = orphNamesOfCo co++orphNamesOfCo :: Coercion -> NameSet+orphNamesOfCo (Refl ty)             = orphNamesOfType ty+orphNamesOfCo (GRefl _ ty mco)      = orphNamesOfType ty `unionNameSet` orphNamesOfMCo mco+orphNamesOfCo (TyConAppCo _ tc cos) = unitNameSet (getName tc) `unionNameSet` orphNamesOfCos cos+orphNamesOfCo (AppCo co1 co2)       = orphNamesOfCo co1 `unionNameSet` orphNamesOfCo co2+orphNamesOfCo (ForAllCo _ kind_co co)+  = orphNamesOfCo kind_co `unionNameSet` orphNamesOfCo co+orphNamesOfCo (FunCo _ co1 co2)     = orphNamesOfCo co1 `unionNameSet` orphNamesOfCo co2+orphNamesOfCo (CoVarCo _)           = emptyNameSet+orphNamesOfCo (AxiomInstCo con _ cos) = orphNamesOfCoCon con `unionNameSet` orphNamesOfCos cos+orphNamesOfCo (UnivCo p _ t1 t2)    = orphNamesOfProv p `unionNameSet` orphNamesOfType t1 `unionNameSet` orphNamesOfType t2+orphNamesOfCo (SymCo co)            = orphNamesOfCo co+orphNamesOfCo (TransCo co1 co2)     = orphNamesOfCo co1 `unionNameSet` orphNamesOfCo co2+orphNamesOfCo (NthCo _ _ co)        = orphNamesOfCo co+orphNamesOfCo (LRCo  _ co)          = orphNamesOfCo co+orphNamesOfCo (InstCo co arg)       = orphNamesOfCo co `unionNameSet` orphNamesOfCo arg+orphNamesOfCo (KindCo co)           = orphNamesOfCo co+orphNamesOfCo (SubCo co)            = orphNamesOfCo co+orphNamesOfCo (AxiomRuleCo _ cs)    = orphNamesOfCos cs+orphNamesOfCo (HoleCo _)            = emptyNameSet++orphNamesOfProv :: UnivCoProvenance -> NameSet+orphNamesOfProv (PhantomProv co)    = orphNamesOfCo co+orphNamesOfProv (ProofIrrelProv co) = orphNamesOfCo co+orphNamesOfProv (PluginProv _)      = emptyNameSet++orphNamesOfCos :: [Coercion] -> NameSet+orphNamesOfCos = orphNamesOfThings orphNamesOfCo++orphNamesOfCoCon :: CoAxiom br -> NameSet+orphNamesOfCoCon (CoAxiom { co_ax_tc = tc, co_ax_branches = branches })+  = orphNamesOfTyCon tc `unionNameSet` orphNamesOfCoAxBranches branches++orphNamesOfAxiom :: CoAxiom br -> NameSet+orphNamesOfAxiom axiom+  = orphNamesOfTypes (concatMap coAxBranchLHS $ fromBranches $ coAxiomBranches axiom)+    `extendNameSet` getName (coAxiomTyCon axiom)++orphNamesOfCoAxBranches :: Branches br -> NameSet+orphNamesOfCoAxBranches+  = foldr (unionNameSet . orphNamesOfCoAxBranch) emptyNameSet . fromBranches++orphNamesOfCoAxBranch :: CoAxBranch -> NameSet+orphNamesOfCoAxBranch (CoAxBranch { cab_lhs = lhs, cab_rhs = rhs })+  = orphNamesOfTypes lhs `unionNameSet` orphNamesOfType rhs++-- | orphNamesOfAxiom collects the names of the concrete types and+-- type constructors that make up the LHS of a type family instance,+-- including the family name itself.+--+-- For instance, given `type family Foo a b`:+-- `type instance Foo (F (G (H a))) b = ...` would yield [Foo,F,G,H]+--+-- Used in the implementation of ":info" in GHCi.+orphNamesOfFamInst :: FamInst -> NameSet+orphNamesOfFamInst fam_inst = orphNamesOfAxiom (famInstAxiom fam_inst)++{-+************************************************************************+*                                                                      *+\section[freevars-everywhere]{Attaching free variables to every sub-expression}+*                                                                      *+************************************************************************+-}++-- | Those variables free in the right hand side of a rule returned as a+-- non-deterministic set+ruleRhsFreeVars :: CoreRule -> VarSet+ruleRhsFreeVars (BuiltinRule {}) = noFVs+ruleRhsFreeVars (Rule { ru_fn = _, ru_bndrs = bndrs, ru_rhs = rhs })+  = fvVarSet $ filterFV isLocalVar $ addBndrs bndrs (expr_fvs rhs)+      -- See Note [Rule free var hack]++-- | Those variables free in the both the left right hand sides of a rule+-- returned as a non-deterministic set+ruleFreeVars :: CoreRule -> VarSet+ruleFreeVars = fvVarSet . ruleFVs++-- | Those variables free in the both the left right hand sides of a rule+-- returned as FV computation+ruleFVs :: CoreRule -> FV+ruleFVs (BuiltinRule {}) = emptyFV+ruleFVs (Rule { ru_fn = _do_not_include+                  -- See Note [Rule free var hack]+              , ru_bndrs = bndrs+              , ru_rhs = rhs, ru_args = args })+  = filterFV isLocalVar $ addBndrs bndrs (exprs_fvs (rhs:args))++-- | Those variables free in the both the left right hand sides of rules+-- returned as FV computation+rulesFVs :: [CoreRule] -> FV+rulesFVs = mapUnionFV ruleFVs++-- | Those variables free in the both the left right hand sides of rules+-- returned as a deterministic set+rulesFreeVarsDSet :: [CoreRule] -> DVarSet+rulesFreeVarsDSet rules = fvDVarSet $ rulesFVs rules++idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet+-- Just the variables free on the *rhs* of a rule+idRuleRhsVars is_active id+  = mapUnionVarSet get_fvs (idCoreRules id)+  where+    get_fvs (Rule { ru_fn = fn, ru_bndrs = bndrs+                  , ru_rhs = rhs, ru_act = act })+      | is_active act+            -- See Note [Finding rule RHS free vars] in OccAnal.hs+      = delOneFromUniqSet_Directly fvs (getUnique fn)+            -- Note [Rule free var hack]+      where+        fvs = fvVarSet $ filterFV isLocalVar $ addBndrs bndrs (expr_fvs rhs)+    get_fvs _ = noFVs++-- | Those variables free in the right hand side of several rules+rulesFreeVars :: [CoreRule] -> VarSet+rulesFreeVars rules = mapUnionVarSet ruleFreeVars rules++ruleLhsFreeIds :: CoreRule -> VarSet+-- ^ This finds all locally-defined free Ids on the left hand side of a rule+-- and returns them as a non-deterministic set+ruleLhsFreeIds = fvVarSet . ruleLhsFVIds++ruleLhsFreeIdsList :: CoreRule -> [Var]+-- ^ This finds all locally-defined free Ids on the left hand side of a rule+-- and returns them as a deterministically ordered list+ruleLhsFreeIdsList = fvVarList . ruleLhsFVIds++ruleLhsFVIds :: CoreRule -> FV+-- ^ This finds all locally-defined free Ids on the left hand side of a rule+-- and returns an FV computation+ruleLhsFVIds (BuiltinRule {}) = emptyFV+ruleLhsFVIds (Rule { ru_bndrs = bndrs, ru_args = args })+  = filterFV isLocalId $ addBndrs bndrs (exprs_fvs args)++{-+Note [Rule free var hack]  (Not a hack any more)+~~~~~~~~~~~~~~~~~~~~~~~~~+We used not to include the Id in its own rhs free-var set.+Otherwise the occurrence analyser makes bindings recursive:+        f x y = x+y+        RULE:  f (f x y) z  ==>  f x (f y z)+However, the occurrence analyser distinguishes "non-rule loop breakers"+from "rule-only loop breakers" (see BasicTypes.OccInfo).  So it will+put this 'f' in a Rec block, but will mark the binding as a non-rule loop+breaker, which is perfectly inlinable.+-}++{-+************************************************************************+*                                                                      *+\section[freevars-everywhere]{Attaching free variables to every sub-expression}+*                                                                      *+************************************************************************++The free variable pass annotates every node in the expression with its+NON-GLOBAL free variables and type variables.+-}++type FVAnn = DVarSet  -- See Note [The FVAnn invariant]++{- Note [The FVAnn invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Invariant: a FVAnn, say S, is closed:+  That is: if v is in S,+           then freevars( v's type/kind ) is also in S+-}++-- | Every node in a binding group annotated with its+-- (non-global) free variables, both Ids and TyVars, and type.+type CoreBindWithFVs = AnnBind Id FVAnn++-- | Every node in an expression annotated with its+-- (non-global) free variables, both Ids and TyVars, and type.+-- NB: see Note [The FVAnn invariant]+type CoreExprWithFVs  = AnnExpr  Id FVAnn+type CoreExprWithFVs' = AnnExpr' Id FVAnn++-- | Every node in an expression annotated with its+-- (non-global) free variables, both Ids and TyVars, and type.+type CoreAltWithFVs = AnnAlt Id FVAnn++freeVarsOf :: CoreExprWithFVs -> DIdSet+-- ^ Inverse function to 'freeVars'+freeVarsOf (fvs, _) = fvs++-- | Extract the vars reported in a FVAnn+freeVarsOfAnn :: FVAnn -> DIdSet+freeVarsOfAnn fvs = fvs++noFVs :: VarSet+noFVs = emptyVarSet++aFreeVar :: Var -> DVarSet+aFreeVar = unitDVarSet++unionFVs :: DVarSet -> DVarSet -> DVarSet+unionFVs = unionDVarSet++unionFVss :: [DVarSet] -> DVarSet+unionFVss = unionDVarSets++delBindersFV :: [Var] -> DVarSet -> DVarSet+delBindersFV bs fvs = foldr delBinderFV fvs bs++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,+--   * 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.+--+-- Also in+--      let x::a = b in ...+-- we should really note that "a" is free in this expression.+-- It'll be pinned inside the /\a by the binding for b, but+-- it seems cleaner to make sure that a is in the free-var set+-- when it is mentioned.+--+-- This also shows up in recursive bindings.  Consider:+--      /\a -> letrec x::a = x in E+-- Now, there are no explicit free type variables in the RHS of x,+-- but nevertheless "a" is free in its definition.  So we add in+-- the free tyvars of the types of the binders, and include these in the+-- free vars of the group, attached to the top level of each RHS.+--+-- This actually happened in the defn of errorIO in IOBase.hs:+--      errorIO (ST io) = case (errorIO# io) of+--                          _ -> bottom+--                        where+--                          bottom = bottom -- Never evaluated++delBinderFV b s = (s `delDVarSet` b) `unionFVs` dVarTypeTyCoVars b+        -- Include coercion variables too!++varTypeTyCoVars :: Var -> TyCoVarSet+-- Find the type/kind variables free in the type of the id/tyvar+varTypeTyCoVars var = fvVarSet $ varTypeTyCoFVs var++dVarTypeTyCoVars :: Var -> DTyCoVarSet+-- Find the type/kind/coercion variables free in the type of the id/tyvar+dVarTypeTyCoVars var = fvDVarSet $ varTypeTyCoFVs var++varTypeTyCoFVs :: Var -> FV+varTypeTyCoFVs var = tyCoFVsOfType (varType var)++idFreeVars :: Id -> VarSet+idFreeVars id = ASSERT( isId id) fvVarSet $ idFVs id++dIdFreeVars :: Id -> DVarSet+dIdFreeVars id = fvDVarSet $ idFVs id++idFVs :: Id -> FV+-- Type variables, rule variables, and inline variables+idFVs id = ASSERT( isId id)+           varTypeTyCoFVs id `unionFV`+           bndrRuleAndUnfoldingFVs id++bndrRuleAndUnfoldingVarsDSet :: Id -> DVarSet+bndrRuleAndUnfoldingVarsDSet id = fvDVarSet $ bndrRuleAndUnfoldingFVs id++bndrRuleAndUnfoldingFVs :: Id -> FV+bndrRuleAndUnfoldingFVs id+  | isId id   = idRuleFVs id `unionFV` idUnfoldingFVs id+  | otherwise = emptyFV++idRuleVars ::Id -> VarSet  -- Does *not* include CoreUnfolding vars+idRuleVars id = fvVarSet $ idRuleFVs id++idRuleFVs :: Id -> FV+idRuleFVs id = ASSERT( isId id)+  FV.mkFVs (dVarSetElems $ ruleInfoFreeVars (idSpecialisation id))++idUnfoldingVars :: Id -> VarSet+-- Produce free vars for an unfolding, but NOT for an ordinary+-- (non-inline) unfolding, since it is a dup of the rhs+-- and we'll get exponential behaviour if we look at both unf and rhs!+-- But do look at the *real* unfolding, even for loop breakers, else+-- we might get out-of-scope variables+idUnfoldingVars id = fvVarSet $ idUnfoldingFVs id++idUnfoldingFVs :: Id -> FV+idUnfoldingFVs id = stableUnfoldingFVs (realIdUnfolding id) `orElse` emptyFV++stableUnfoldingVars :: Unfolding -> Maybe VarSet+stableUnfoldingVars unf = fvVarSet `fmap` stableUnfoldingFVs unf++stableUnfoldingFVs :: Unfolding -> Maybe FV+stableUnfoldingFVs unf+  = case unf of+      CoreUnfolding { uf_tmpl = rhs, uf_src = src }+         | isStableSource src+         -> Just (filterFV isLocalVar $ expr_fvs rhs)+      DFunUnfolding { df_bndrs = bndrs, df_args = args }+         -> Just (filterFV isLocalVar $ FV.delFVs (mkVarSet bndrs) $ exprs_fvs args)+            -- DFuns are top level, so no fvs from types of bndrs+      _other -> Nothing+++{-+************************************************************************+*                                                                      *+\subsection{Free variables (and types)}+*                                                                      *+************************************************************************+-}++freeVarsBind :: CoreBind+             -> DVarSet                     -- Free vars of scope of binding+             -> (CoreBindWithFVs, DVarSet)  -- Return free vars of binding + scope+freeVarsBind (NonRec binder rhs) body_fvs+  = ( AnnNonRec binder rhs2+    , freeVarsOf rhs2 `unionFVs` body_fvs2+                      `unionFVs` bndrRuleAndUnfoldingVarsDSet binder )+    where+      rhs2      = freeVars rhs+      body_fvs2 = binder `delBinderFV` body_fvs++freeVarsBind (Rec binds) body_fvs+  = ( AnnRec (binders `zip` rhss2)+    , delBindersFV binders all_fvs )+  where+    (binders, rhss) = unzip binds+    rhss2        = map freeVars rhss+    rhs_body_fvs = foldr (unionFVs . freeVarsOf) body_fvs rhss2+    binders_fvs  = fvDVarSet $ mapUnionFV bndrRuleAndUnfoldingFVs binders+                   -- See Note [The FVAnn invariant]+    all_fvs      = rhs_body_fvs `unionFVs` binders_fvs+            -- The "delBinderFV" happens after adding the idSpecVars,+            -- since the latter may add some of the binders as fvs++freeVars :: CoreExpr -> CoreExprWithFVs+-- ^ Annotate a 'CoreExpr' with its (non-global) free type+--   and value variables at every tree node.+freeVars = go+  where+    go :: CoreExpr -> CoreExprWithFVs+    go (Var v)+      | isLocalVar v = (aFreeVar v `unionFVs` ty_fvs, AnnVar v)+      | otherwise    = (emptyDVarSet,                 AnnVar v)+      where+        ty_fvs = dVarTypeTyCoVars v+                 -- See Note [The FVAnn invariant]++    go (Lit lit) = (emptyDVarSet, AnnLit lit)+    go (Lam b body)+      = ( b_fvs `unionFVs` (b `delBinderFV` body_fvs)+        , AnnLam b body' )+      where+        body'@(body_fvs, _) = go body+        b_ty  = idType b+        b_fvs = tyCoVarsOfTypeDSet b_ty+                -- See Note [The FVAnn invariant]++    go (App fun arg)+      = ( freeVarsOf fun' `unionFVs` freeVarsOf arg'+        , AnnApp fun' arg' )+      where+        fun'   = go fun+        arg'   = go arg++    go (Case scrut bndr ty alts)+      = ( (bndr `delBinderFV` alts_fvs)+           `unionFVs` freeVarsOf scrut2+           `unionFVs` tyCoVarsOfTypeDSet ty+          -- Don't need to look at (idType bndr)+          -- because that's redundant with scrut+        , AnnCase scrut2 bndr ty alts2 )+      where+        scrut2 = go scrut++        (alts_fvs_s, alts2) = mapAndUnzip fv_alt alts+        alts_fvs            = unionFVss alts_fvs_s++        fv_alt (con,args,rhs) = (delBindersFV args (freeVarsOf rhs2),+                                 (con, args, rhs2))+                              where+                                 rhs2 = go rhs++    go (Let bind body)+      = (bind_fvs, AnnLet bind2 body2)+      where+        (bind2, bind_fvs) = freeVarsBind bind (freeVarsOf body2)+        body2             = go body++    go (Cast expr co)+      = ( freeVarsOf expr2 `unionFVs` cfvs+        , AnnCast expr2 (cfvs, co) )+      where+        expr2 = go expr+        cfvs  = tyCoVarsOfCoDSet co++    go (Tick tickish expr)+      = ( tickishFVs tickish `unionFVs` freeVarsOf expr2+        , AnnTick tickish expr2 )+      where+        expr2 = go expr+        tickishFVs (Breakpoint _ ids) = mkDVarSet ids+        tickishFVs _                  = emptyDVarSet++    go (Type ty)     = (tyCoVarsOfTypeDSet ty, AnnType ty)+    go (Coercion co) = (tyCoVarsOfCoDSet co, AnnCoercion co)

+ compiler/GHC/Core/Make.hs view

@@ -0,0 +1,940 @@+{-# LANGUAGE CPP #-}++{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++-- | Handy functions for creating much Core syntax+module GHC.Core.Make (+        -- * Constructing normal syntax+        mkCoreLet, mkCoreLets,+        mkCoreApp, mkCoreApps, mkCoreConApps,+        mkCoreLams, mkWildCase, mkIfThenElse,+        mkWildValBinder, mkWildEvBinder,+        mkSingleAltCase,+        sortQuantVars, castBottomExpr,++        -- * Constructing boxed literals+        mkWordExpr, mkWordExprWord,+        mkIntExpr, mkIntExprInt,+        mkIntegerExpr, mkNaturalExpr,+        mkFloatExpr, mkDoubleExpr,+        mkCharExpr, mkStringExpr, mkStringExprFS, mkStringExprFSWith,++        -- * Floats+        FloatBind(..), wrapFloat, wrapFloats, floatBindings,++        -- * Constructing small tuples+        mkCoreVarTupTy, mkCoreTup, mkCoreUbxTup,+        mkCoreTupBoxity, unitExpr,++        -- * Constructing big tuples+        mkBigCoreVarTup, mkBigCoreVarTup1,+        mkBigCoreVarTupTy, mkBigCoreTupTy,+        mkBigCoreTup,++        -- * Deconstructing small tuples+        mkSmallTupleSelector, mkSmallTupleCase,++        -- * Deconstructing big tuples+        mkTupleSelector, mkTupleSelector1, mkTupleCase,++        -- * Constructing list expressions+        mkNilExpr, mkConsExpr, mkListExpr,+        mkFoldrExpr, mkBuildExpr,++        -- * Constructing Maybe expressions+        mkNothingExpr, mkJustExpr,++        -- * Error Ids+        mkRuntimeErrorApp, mkImpossibleExpr, mkAbsentErrorApp, errorIds,+        rEC_CON_ERROR_ID, rUNTIME_ERROR_ID,+        nON_EXHAUSTIVE_GUARDS_ERROR_ID, nO_METHOD_BINDING_ERROR_ID,+        pAT_ERROR_ID, rEC_SEL_ERROR_ID, aBSENT_ERROR_ID,+        tYPE_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID+    ) where++#include "HsVersions.h"++import GhcPrelude++import Id+import Var      ( EvVar, setTyVarUnique )++import GHC.Core+import GHC.Core.Utils ( exprType, needsCaseBinding, mkSingleAltCase, bindNonRec )+import Literal+import GHC.Driver.Types++import TysWiredIn+import PrelNames++import GHC.Hs.Utils     ( mkChunkified, chunkify )+import Type+import Coercion         ( isCoVar )+import TysPrim+import DataCon          ( DataCon, dataConWorkId )+import IdInfo+import Demand+import Cpr+import Name      hiding ( varName )+import Outputable+import FastString+import UniqSupply+import BasicTypes+import Util+import GHC.Driver.Session+import Data.List++import Data.Char        ( ord )+import Control.Monad.Fail as MonadFail ( MonadFail )++infixl 4 `mkCoreApp`, `mkCoreApps`++{-+************************************************************************+*                                                                      *+\subsection{Basic GHC.Core construction}+*                                                                      *+************************************************************************+-}+sortQuantVars :: [Var] -> [Var]+-- Sort the variables, putting type and covars first, in scoped order,+-- and then other Ids+-- It is a deterministic sort, meaining it doesn't look at the values of+-- Uniques. For explanation why it's important See Note [Unique Determinism]+-- in Unique.+sortQuantVars vs = sorted_tcvs ++ ids+  where+    (tcvs, ids) = partition (isTyVar <||> isCoVar) vs+    sorted_tcvs = scopedSort tcvs++-- | Bind a binding group over an expression, using a @let@ or @case@ as+-- appropriate (see "GHC.Core#let_app_invariant")+mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr+mkCoreLet (NonRec bndr rhs) body        -- See Note [Core let/app invariant]+  = bindNonRec bndr rhs body+mkCoreLet bind body+  = Let bind body++-- | Create a lambda where the given expression has a number of variables+-- bound over it. The leftmost binder is that bound by the outermost+-- lambda in the result+mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr+mkCoreLams = mkLams++-- | Bind a list of binding groups over an expression. The leftmost binding+-- group becomes the outermost group in the resulting expression+mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr+mkCoreLets binds body = foldr mkCoreLet body binds++-- | Construct an expression which represents the application of a number of+-- expressions to that of a data constructor expression. The leftmost expression+-- in the list is applied first+mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr+mkCoreConApps con args = mkCoreApps (Var (dataConWorkId con)) args++-- | 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 Note [Core let/app invariant] in GHC.Core+mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr+mkCoreApps fun args+  = fst $+    foldl' (mkCoreAppTyped doc_string) (fun, fun_ty) args+  where+    doc_string = ppr fun_ty $$ ppr fun $$ ppr args+    fun_ty = exprType fun++-- | Construct an expression which represents the application of one expression+-- to the other+-- Respects the let/app invariant by building a case expression where necessary+--   See Note [Core let/app invariant] in GHC.Core+mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr+mkCoreApp s fun arg+  = fst $ mkCoreAppTyped s (fun, exprType fun) arg++-- | 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 Note [Core let/app invariant] in GHC.Core+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), funResultTy fun_ty)+mkCoreAppTyped d (fun, fun_ty) arg+  = ASSERT2( isFunTy fun_ty, ppr fun $$ ppr arg $$ d )+    (mkValApp fun arg arg_ty res_ty, res_ty)+  where+    (arg_ty, res_ty) = splitFunTy fun_ty++mkValApp :: CoreExpr -> CoreExpr -> Type -> Type -> CoreExpr+-- Build an application (e1 e2),+-- or a strict binding  (case e2 of x -> e1 x)+-- using the latter when necessary to respect the let/app invariant+--   See Note [Core let/app invariant] in GHC.Core+mkValApp fun arg arg_ty res_ty+  | not (needsCaseBinding arg_ty arg)+  = App fun arg                -- The vastly common case+  | otherwise+  = mkStrictApp fun arg arg_ty res_ty++{- *********************************************************************+*                                                                      *+              Building case expressions+*                                                                      *+********************************************************************* -}++mkWildEvBinder :: PredType -> EvVar+mkWildEvBinder pred = mkWildValBinder pred++-- | Make a /wildcard binder/. This is typically used when you need a binder+-- that you expect to use only at a *binding* site.  Do not use it at+-- occurrence sites because it has a single, fixed unique, and it's very+-- easy to get into difficulties with shadowing.  That's why it is used so little.+-- See Note [WildCard binders] in SimplEnv+mkWildValBinder :: Type -> Id+mkWildValBinder ty = mkLocalIdOrCoVar wildCardName ty+  -- "OrCoVar" since a coercion can be a scrutinee with -fdefer-type-errors+  -- (e.g. see test T15695). Ticket #17291 covers fixing this problem.++mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr+-- Make a case expression whose case binder is unused+-- The alts and res_ty should not have any occurrences of WildId+mkWildCase scrut scrut_ty res_ty alts+  = Case scrut (mkWildValBinder scrut_ty) res_ty alts++mkStrictApp :: CoreExpr -> CoreExpr -> Type -> Type -> CoreExpr+-- Build a strict application (case e2 of x -> e1 x)+mkStrictApp fun arg arg_ty res_ty+  = Case arg arg_id res_ty [(DEFAULT,[],App fun (Var arg_id))]+       -- mkDefaultCase looks attractive here, and would be sound.+       -- But it uses (exprType alt_rhs) to compute the result type,+       -- whereas here we already know that the result type is res_ty+  where+    arg_id = mkWildValBinder arg_ty+        -- Lots of shadowing, but it doesn't matter,+        -- because 'fun' and 'res_ty' should not have a free wild-id+        --+        -- This is Dangerous.  But this is the only place we play this+        -- game, mkStrictApp returns an expression that does not have+        -- a free wild-id.  So the only way 'fun' could get a free wild-id+        -- would be if you take apart this case expression (or some other+        -- expression that uses mkWildValBinder, of which there are not+        -- many), and pass a fragment of it as the fun part of a 'mkStrictApp'.++mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr+mkIfThenElse guard then_expr else_expr+-- Not going to be refining, so okay to take the type of the "then" clause+  = mkWildCase guard boolTy (exprType then_expr)+         [ (DataAlt falseDataCon, [], else_expr),       -- Increasing order of tag!+           (DataAlt trueDataCon,  [], then_expr) ]++castBottomExpr :: CoreExpr -> Type -> CoreExpr+-- (castBottomExpr e ty), assuming that 'e' diverges,+-- return an expression of type 'ty'+-- See Note [Empty case alternatives] in GHC.Core+castBottomExpr e res_ty+  | e_ty `eqType` res_ty = e+  | otherwise            = Case e (mkWildValBinder e_ty) res_ty []+  where+    e_ty = exprType e++{-+************************************************************************+*                                                                      *+\subsection{Making literals}+*                                                                      *+************************************************************************+-}++-- | Create a 'CoreExpr' which will evaluate to the given @Int@+mkIntExpr :: DynFlags -> Integer -> CoreExpr        -- Result = I# i :: Int+mkIntExpr dflags i = mkCoreConApps intDataCon  [mkIntLit dflags i]++-- | Create a 'CoreExpr' which will evaluate to the given @Int@+mkIntExprInt :: DynFlags -> Int -> CoreExpr         -- Result = I# i :: Int+mkIntExprInt dflags i = mkCoreConApps intDataCon  [mkIntLitInt dflags i]++-- | Create a 'CoreExpr' which will evaluate to the a @Word@ with the given value+mkWordExpr :: DynFlags -> Integer -> CoreExpr+mkWordExpr dflags w = mkCoreConApps wordDataCon [mkWordLit dflags w]++-- | Create a 'CoreExpr' which will evaluate to the given @Word@+mkWordExprWord :: DynFlags -> Word -> CoreExpr+mkWordExprWord dflags w = mkCoreConApps wordDataCon [mkWordLitWord dflags w]++-- | Create a 'CoreExpr' which will evaluate to the given @Integer@+mkIntegerExpr  :: MonadThings m => Integer -> m CoreExpr  -- Result :: Integer+mkIntegerExpr i = do t <- lookupTyCon integerTyConName+                     return (Lit (mkLitInteger i (mkTyConTy t)))++-- | Create a 'CoreExpr' which will evaluate to the given @Natural@+mkNaturalExpr  :: MonadThings m => Integer -> m CoreExpr+mkNaturalExpr i = do t <- lookupTyCon naturalTyConName+                     return (Lit (mkLitNatural i (mkTyConTy t)))++-- | Create a 'CoreExpr' which will evaluate to the given @Float@+mkFloatExpr :: Float -> CoreExpr+mkFloatExpr f = mkCoreConApps floatDataCon [mkFloatLitFloat f]++-- | Create a 'CoreExpr' which will evaluate to the given @Double@+mkDoubleExpr :: Double -> CoreExpr+mkDoubleExpr d = mkCoreConApps doubleDataCon [mkDoubleLitDouble d]+++-- | Create a 'CoreExpr' which will evaluate to the given @Char@+mkCharExpr     :: Char             -> CoreExpr      -- Result = C# c :: Int+mkCharExpr c = mkCoreConApps charDataCon [mkCharLit c]++-- | Create a 'CoreExpr' which will evaluate to the given @String@+mkStringExpr   :: MonadThings m => String     -> m CoreExpr  -- Result :: String++-- | Create a 'CoreExpr' which will evaluate to a string morally equivalent to the given @FastString@+mkStringExprFS :: MonadThings m => FastString -> m CoreExpr  -- Result :: String++mkStringExpr str = mkStringExprFS (mkFastString str)++mkStringExprFS = mkStringExprFSWith lookupId++mkStringExprFSWith :: Monad m => (Name -> m Id) -> FastString -> m CoreExpr+mkStringExprFSWith lookupM str+  | nullFS str+  = return (mkNilExpr charTy)++  | all safeChar chars+  = do unpack_id <- lookupM unpackCStringName+       return (App (Var unpack_id) lit)++  | otherwise+  = do unpack_utf8_id <- lookupM unpackCStringUtf8Name+       return (App (Var unpack_utf8_id) lit)++  where+    chars = unpackFS str+    safeChar c = ord c >= 1 && ord c <= 0x7F+    lit = Lit (LitString (bytesFS str))++{-+************************************************************************+*                                                                      *+\subsection{Tuple constructors}+*                                                                      *+************************************************************************+-}++{-+Creating tuples and their types for Core expressions++@mkBigCoreVarTup@ builds a tuple; the inverse to @mkTupleSelector@.++* If it has only one element, it is the identity function.++* If there are more elements than a big tuple can have, it nests+  the tuples.++Note [Flattening one-tuples]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+This family of functions creates a tuple of variables/expressions/types.+  mkCoreTup [e1,e2,e3] = (e1,e2,e3)+What if there is just one variable/expression/type in the argument?+We could do one of two things:++* Flatten it out, so that+    mkCoreTup [e1] = e1++* Build a one-tuple (see Note [One-tuples] in TysWiredIn)+    mkCoreTup1 [e1] = Unit e1+  We use a suffix "1" to indicate this.++Usually we want the former, but occasionally the latter.++NB: The logic in tupleDataCon knows about () and Unit and (,), etc.++Note [Don't flatten tuples from HsSyn]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we get an explicit 1-tuple from HsSyn somehow (likely: Template Haskell),+we should treat it really as a 1-tuple, without flattening. Note that a+1-tuple and a flattened value have different performance and laziness+characteristics, so should just do what we're asked.++This arose from discussions in #16881.++One-tuples that arise internally depend on the circumstance; often flattening+is a good idea. Decisions are made on a case-by-case basis.++-}++-- | Build the type of a small tuple that holds the specified variables+-- One-tuples are flattened; see Note [Flattening one-tuples]+mkCoreVarTupTy :: [Id] -> Type+mkCoreVarTupTy ids = mkBoxedTupleTy (map idType ids)++-- | Build a small tuple holding the specified expressions+-- One-tuples are flattened; see Note [Flattening one-tuples]+mkCoreTup :: [CoreExpr] -> CoreExpr+mkCoreTup [c] = c+mkCoreTup cs  = mkCoreTup1 cs   -- non-1-tuples are uniform++-- | Build a small tuple holding the specified expressions+-- One-tuples are *not* flattened; see Note [Flattening one-tuples]+-- See also Note [Don't flatten tuples from HsSyn]+mkCoreTup1 :: [CoreExpr] -> CoreExpr+mkCoreTup1 cs = mkCoreConApps (tupleDataCon Boxed (length cs))+                              (map (Type . exprType) cs ++ cs)++-- | Build a small unboxed tuple holding the specified expressions,+-- with the given types. The types must be the types of the expressions.+-- Do not include the RuntimeRep specifiers; this function calculates them+-- for you.+-- Does /not/ flatten one-tuples; see Note [Flattening one-tuples]+mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr+mkCoreUbxTup tys exps+  = ASSERT( tys `equalLength` exps)+    mkCoreConApps (tupleDataCon Unboxed (length tys))+             (map (Type . getRuntimeRep) tys ++ map Type tys ++ exps)++-- | Make a core tuple of the given boxity; don't flatten 1-tuples+mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr+mkCoreTupBoxity Boxed   exps = mkCoreTup1 exps+mkCoreTupBoxity Unboxed exps = mkCoreUbxTup (map exprType exps) exps++-- | Build a big tuple holding the specified variables+-- One-tuples are flattened; see Note [Flattening one-tuples]+mkBigCoreVarTup :: [Id] -> CoreExpr+mkBigCoreVarTup ids = mkBigCoreTup (map Var ids)++mkBigCoreVarTup1 :: [Id] -> CoreExpr+-- Same as mkBigCoreVarTup, but one-tuples are NOT flattened+--                          see Note [Flattening one-tuples]+mkBigCoreVarTup1 [id] = mkCoreConApps (tupleDataCon Boxed 1)+                                      [Type (idType id), Var id]+mkBigCoreVarTup1 ids  = mkBigCoreTup (map Var ids)++-- | Build the type of a big tuple that holds the specified variables+-- One-tuples are flattened; see Note [Flattening one-tuples]+mkBigCoreVarTupTy :: [Id] -> Type+mkBigCoreVarTupTy ids = mkBigCoreTupTy (map idType ids)++-- | Build a big tuple holding the specified expressions+-- One-tuples are flattened; see Note [Flattening one-tuples]+mkBigCoreTup :: [CoreExpr] -> CoreExpr+mkBigCoreTup = mkChunkified mkCoreTup++-- | Build the type of a big tuple that holds the specified type of thing+-- One-tuples are flattened; see Note [Flattening one-tuples]+mkBigCoreTupTy :: [Type] -> Type+mkBigCoreTupTy = mkChunkified mkBoxedTupleTy++-- | The unit expression+unitExpr :: CoreExpr+unitExpr = Var unitDataConId++{-+************************************************************************+*                                                                      *+\subsection{Tuple destructors}+*                                                                      *+************************************************************************+-}++-- | Builds a selector which scrutises the given+-- expression and extracts the one name from the list given.+-- If you want the no-shadowing rule to apply, the caller+-- is responsible for making sure that none of these names+-- are in scope.+--+-- If there is just one 'Id' in the tuple, then the selector is+-- just the identity.+--+-- If necessary, we pattern match on a \"big\" tuple.+mkTupleSelector, mkTupleSelector1+    :: [Id]         -- ^ The 'Id's to pattern match the tuple against+    -> Id           -- ^ The 'Id' to select+    -> Id           -- ^ A variable of the same type as the scrutinee+    -> CoreExpr     -- ^ Scrutinee+    -> CoreExpr     -- ^ Selector expression++-- mkTupleSelector [a,b,c,d] b v e+--          = case e of v {+--                (p,q) -> case p of p {+--                           (a,b) -> b }}+-- We use 'tpl' vars for the p,q, since shadowing does not matter.+--+-- In fact, it's more convenient to generate it innermost first, getting+--+--        case (case e of v+--                (p,q) -> p) of p+--          (a,b) -> b+mkTupleSelector vars the_var scrut_var scrut+  = mk_tup_sel (chunkify vars) the_var+  where+    mk_tup_sel [vars] the_var = mkSmallTupleSelector vars the_var scrut_var scrut+    mk_tup_sel vars_s the_var = mkSmallTupleSelector group the_var tpl_v $+                                mk_tup_sel (chunkify tpl_vs) tpl_v+        where+          tpl_tys = [mkBoxedTupleTy (map idType gp) | gp <- vars_s]+          tpl_vs  = mkTemplateLocals tpl_tys+          [(tpl_v, group)] = [(tpl,gp) | (tpl,gp) <- zipEqual "mkTupleSelector" tpl_vs vars_s,+                                         the_var `elem` gp ]+-- ^ 'mkTupleSelector1' is like 'mkTupleSelector'+-- but one-tuples are NOT flattened (see Note [Flattening one-tuples])+mkTupleSelector1 vars the_var scrut_var scrut+  | [_] <- vars+  = mkSmallTupleSelector1 vars the_var scrut_var scrut+  | otherwise+  = mkTupleSelector vars the_var scrut_var scrut++-- | Like 'mkTupleSelector' but for tuples that are guaranteed+-- never to be \"big\".+--+-- > mkSmallTupleSelector [x] x v e = [| e |]+-- > mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]+mkSmallTupleSelector, mkSmallTupleSelector1+          :: [Id]        -- The tuple args+          -> Id          -- The selected one+          -> Id          -- A variable of the same type as the scrutinee+          -> CoreExpr    -- Scrutinee+          -> CoreExpr+mkSmallTupleSelector [var] should_be_the_same_var _ scrut+  = ASSERT(var == should_be_the_same_var)+    scrut  -- Special case for 1-tuples+mkSmallTupleSelector vars the_var scrut_var scrut+  = mkSmallTupleSelector1 vars the_var scrut_var scrut++-- ^ 'mkSmallTupleSelector1' is like 'mkSmallTupleSelector'+-- but one-tuples are NOT flattened (see Note [Flattening one-tuples])+mkSmallTupleSelector1 vars the_var scrut_var scrut+  = ASSERT( notNull vars )+    Case scrut scrut_var (idType the_var)+         [(DataAlt (tupleDataCon Boxed (length vars)), vars, Var the_var)]++-- | A generalization of 'mkTupleSelector', allowing the body+-- of the case to be an arbitrary expression.+--+-- To avoid shadowing, we use uniques to invent new variables.+--+-- If necessary we pattern match on a \"big\" tuple.+mkTupleCase :: UniqSupply       -- ^ For inventing names of intermediate variables+            -> [Id]             -- ^ The tuple identifiers to pattern match on+            -> CoreExpr         -- ^ Body of the case+            -> Id               -- ^ A variable of the same type as the scrutinee+            -> CoreExpr         -- ^ Scrutinee+            -> CoreExpr+-- ToDo: eliminate cases where none of the variables are needed.+--+--         mkTupleCase uniqs [a,b,c,d] body v e+--           = case e of v { (p,q) ->+--             case p of p { (a,b) ->+--             case q of q { (c,d) ->+--             body }}}+mkTupleCase uniqs vars body scrut_var scrut+  = mk_tuple_case uniqs (chunkify vars) body+  where+    -- This is the case where don't need any nesting+    mk_tuple_case _ [vars] body+      = mkSmallTupleCase vars body scrut_var scrut++    -- This is the case where we must make nest tuples at least once+    mk_tuple_case us vars_s body+      = let (us', vars', body') = foldr one_tuple_case (us, [], body) vars_s+            in mk_tuple_case us' (chunkify vars') body'++    one_tuple_case chunk_vars (us, vs, body)+      = let (uniq, us') = takeUniqFromSupply us+            scrut_var = mkSysLocal (fsLit "ds") uniq+              (mkBoxedTupleTy (map idType chunk_vars))+            body' = mkSmallTupleCase chunk_vars body scrut_var (Var scrut_var)+        in (us', scrut_var:vs, body')++-- | As 'mkTupleCase', but for a tuple that is small enough to be guaranteed+-- not to need nesting.+mkSmallTupleCase+        :: [Id]         -- ^ The tuple args+        -> CoreExpr     -- ^ Body of the case+        -> Id           -- ^ A variable of the same type as the scrutinee+        -> CoreExpr     -- ^ Scrutinee+        -> CoreExpr++mkSmallTupleCase [var] body _scrut_var scrut+  = bindNonRec var scrut body+mkSmallTupleCase vars body scrut_var scrut+-- One branch no refinement?+  = Case scrut scrut_var (exprType body)+         [(DataAlt (tupleDataCon Boxed (length vars)), vars, body)]++{-+************************************************************************+*                                                                      *+                Floats+*                                                                      *+************************************************************************+-}++data FloatBind+  = FloatLet  CoreBind+  | FloatCase CoreExpr Id AltCon [Var]+      -- case e of y { C ys -> ... }+      -- See Note [Floating single-alternative cases] in SetLevels++instance Outputable FloatBind where+  ppr (FloatLet b) = text "LET" <+> ppr b+  ppr (FloatCase e b c bs) = hang (text "CASE" <+> ppr e <+> ptext (sLit "of") <+> ppr b)+                                2 (ppr c <+> ppr bs)++wrapFloat :: FloatBind -> CoreExpr -> CoreExpr+wrapFloat (FloatLet defns)       body = Let defns body+wrapFloat (FloatCase e b con bs) body = mkSingleAltCase e b con bs body++-- | Applies the floats from right to left. That is @wrapFloats [b1, b2, …, bn]+-- u = let b1 in let b2 in … in let bn in u@+wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr+wrapFloats floats expr = foldr wrapFloat expr floats++bindBindings :: CoreBind -> [Var]+bindBindings (NonRec b _) = [b]+bindBindings (Rec bnds) = map fst bnds++floatBindings :: FloatBind -> [Var]+floatBindings (FloatLet bnd) = bindBindings bnd+floatBindings (FloatCase _ b _ bs) = b:bs++{-+************************************************************************+*                                                                      *+\subsection{Common list manipulation expressions}+*                                                                      *+************************************************************************++Call the constructor Ids when building explicit lists, so that they+interact well with rules.+-}++-- | Makes a list @[]@ for lists of the specified type+mkNilExpr :: Type -> CoreExpr+mkNilExpr ty = mkCoreConApps nilDataCon [Type ty]++-- | Makes a list @(:)@ for lists of the specified type+mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr+mkConsExpr ty hd tl = mkCoreConApps consDataCon [Type ty, hd, tl]++-- | Make a list containing the given expressions, where the list has the given type+mkListExpr :: Type -> [CoreExpr] -> CoreExpr+mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs++-- | Make a fully applied 'foldr' expression+mkFoldrExpr :: MonadThings m+            => Type             -- ^ Element type of the list+            -> Type             -- ^ Fold result type+            -> CoreExpr         -- ^ "Cons" function expression for the fold+            -> CoreExpr         -- ^ "Nil" expression for the fold+            -> CoreExpr         -- ^ List expression being folded acress+            -> m CoreExpr+mkFoldrExpr elt_ty result_ty c n list = do+    foldr_id <- lookupId foldrName+    return (Var foldr_id `App` Type elt_ty+           `App` Type result_ty+           `App` c+           `App` n+           `App` list)++-- | Make a 'build' expression applied to a locally-bound worker function+mkBuildExpr :: (MonadFail.MonadFail m, MonadThings m, MonadUnique m)+            => Type                                     -- ^ Type of list elements to be built+            -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -- ^ Function that, given information about the 'Id's+                                                        -- of the binders for the build worker function, returns+                                                        -- the body of that worker+            -> m CoreExpr+mkBuildExpr elt_ty mk_build_inside = do+    [n_tyvar] <- newTyVars [alphaTyVar]+    let n_ty = mkTyVarTy n_tyvar+        c_ty = mkVisFunTys [elt_ty, n_ty] n_ty+    [c, n] <- sequence [mkSysLocalM (fsLit "c") c_ty, mkSysLocalM (fsLit "n") n_ty]++    build_inside <- mk_build_inside (c, c_ty) (n, n_ty)++    build_id <- lookupId buildName+    return $ Var build_id `App` Type elt_ty `App` mkLams [n_tyvar, c, n] build_inside+  where+    newTyVars tyvar_tmpls = do+      uniqs <- getUniquesM+      return (zipWith setTyVarUnique tyvar_tmpls uniqs)++{-+************************************************************************+*                                                                      *+             Manipulating Maybe data type+*                                                                      *+************************************************************************+-}+++-- | Makes a Nothing for the specified type+mkNothingExpr :: Type -> CoreExpr+mkNothingExpr ty = mkConApp nothingDataCon [Type ty]++-- | Makes a Just from a value of the specified type+mkJustExpr :: Type -> CoreExpr -> CoreExpr+mkJustExpr ty val = mkConApp justDataCon [Type ty, val]+++{-+************************************************************************+*                                                                      *+                      Error expressions+*                                                                      *+************************************************************************+-}++mkRuntimeErrorApp+        :: Id           -- Should be of type (forall a. Addr# -> a)+                        --      where Addr# points to a UTF8 encoded string+        -> Type         -- The type to instantiate 'a'+        -> String       -- The string to print+        -> CoreExpr++mkRuntimeErrorApp err_id res_ty err_msg+  = mkApps (Var err_id) [ Type (getRuntimeRep res_ty)+                        , Type res_ty, err_string ]+  where+    err_string = Lit (mkLitString err_msg)++mkImpossibleExpr :: Type -> CoreExpr+mkImpossibleExpr res_ty+  = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty "Impossible case alternative"++{-+************************************************************************+*                                                                      *+                     Error Ids+*                                                                      *+************************************************************************++GHC randomly injects these into the code.++@patError@ is just a version of @error@ for pattern-matching+failures.  It knows various ``codes'' which expand to longer+strings---this saves space!++@absentErr@ is a thing we put in for ``absent'' arguments.  They jolly+well shouldn't be yanked on, but if one is, then you will get a+friendly message from @absentErr@ (rather than a totally random+crash).++@parError@ is a special version of @error@ which the compiler does+not know to be a bottoming Id.  It is used in the @_par_@ and @_seq_@+templates, but we don't ever expect to generate code for it.+-}++errorIds :: [Id]+errorIds+  = [ rUNTIME_ERROR_ID,+      nON_EXHAUSTIVE_GUARDS_ERROR_ID,+      nO_METHOD_BINDING_ERROR_ID,+      pAT_ERROR_ID,+      rEC_CON_ERROR_ID,+      rEC_SEL_ERROR_ID,+      aBSENT_ERROR_ID,+      tYPE_ERROR_ID   -- Used with Opt_DeferTypeErrors, see #10284+      ]++recSelErrorName, runtimeErrorName, absentErrorName :: Name+recConErrorName, patErrorName :: Name+nonExhaustiveGuardsErrorName, noMethodBindingErrorName :: Name+typeErrorName :: Name+absentSumFieldErrorName :: Name++recSelErrorName     = err_nm "recSelError"     recSelErrorIdKey     rEC_SEL_ERROR_ID+absentErrorName     = err_nm "absentError"     absentErrorIdKey     aBSENT_ERROR_ID+absentSumFieldErrorName = err_nm "absentSumFieldError"  absentSumFieldErrorIdKey+                            aBSENT_SUM_FIELD_ERROR_ID+runtimeErrorName    = err_nm "runtimeError"    runtimeErrorIdKey    rUNTIME_ERROR_ID+recConErrorName     = err_nm "recConError"     recConErrorIdKey     rEC_CON_ERROR_ID+patErrorName        = err_nm "patError"        patErrorIdKey        pAT_ERROR_ID+typeErrorName       = err_nm "typeError"       typeErrorIdKey       tYPE_ERROR_ID++noMethodBindingErrorName     = err_nm "noMethodBindingError"+                                  noMethodBindingErrorIdKey nO_METHOD_BINDING_ERROR_ID+nonExhaustiveGuardsErrorName = err_nm "nonExhaustiveGuardsError"+                                  nonExhaustiveGuardsErrorIdKey nON_EXHAUSTIVE_GUARDS_ERROR_ID++err_nm :: String -> Unique -> Id -> Name+err_nm str uniq id = mkWiredInIdName cONTROL_EXCEPTION_BASE (fsLit str) uniq id++rEC_SEL_ERROR_ID, rUNTIME_ERROR_ID, rEC_CON_ERROR_ID :: Id+pAT_ERROR_ID, nO_METHOD_BINDING_ERROR_ID, nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id+tYPE_ERROR_ID, aBSENT_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID :: Id+rEC_SEL_ERROR_ID                = mkRuntimeErrorId recSelErrorName+rUNTIME_ERROR_ID                = mkRuntimeErrorId runtimeErrorName+rEC_CON_ERROR_ID                = mkRuntimeErrorId recConErrorName+pAT_ERROR_ID                    = mkRuntimeErrorId patErrorName+nO_METHOD_BINDING_ERROR_ID      = mkRuntimeErrorId noMethodBindingErrorName+nON_EXHAUSTIVE_GUARDS_ERROR_ID  = mkRuntimeErrorId nonExhaustiveGuardsErrorName+tYPE_ERROR_ID                   = mkRuntimeErrorId typeErrorName++-- Note [aBSENT_SUM_FIELD_ERROR_ID]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- Absent argument error for unused unboxed sum fields are different than absent+-- error used in dummy worker functions (see `mkAbsentErrorApp`):+--+-- - `absentSumFieldError` can't take arguments because it's used in unarise for+--   unused pointer fields in unboxed sums, and applying an argument would+--   require allocating a thunk.+--+-- - `absentSumFieldError` can't be CAFFY because that would mean making some+--   non-CAFFY definitions that use unboxed sums CAFFY in unarise.+--+--   To make `absentSumFieldError` non-CAFFY we get a stable pointer to it in+--   RtsStartup.c and mark it as non-CAFFY here.+--+-- Getting this wrong causes hard-to-debug runtime issues, see #15038.+--+-- TODO: Remove stable pointer hack after fixing #9718.+--       However, we should still be careful about not making things CAFFY just+--       because they use unboxed sums. Unboxed objects are supposed to be+--       efficient, and none of the other unboxed literals make things CAFFY.++aBSENT_SUM_FIELD_ERROR_ID+  = mkVanillaGlobalWithInfo absentSumFieldErrorName+      (mkSpecForAllTys [alphaTyVar] (mkTyVarTy alphaTyVar)) -- forall a . a+      (vanillaIdInfo `setStrictnessInfo` mkClosedStrictSig [] botDiv+                     `setCprInfo` mkCprSig 0 botCpr+                     `setArityInfo` 0+                     `setCafInfo` NoCafRefs) -- #15038++mkRuntimeErrorId :: Name -> Id+-- Error function+--   with type:  forall (r:RuntimeRep) (a:TYPE r). Addr# -> a+--   with arity: 1+-- which diverges after being given one argument+-- The Addr# is expected to be the address of+--   a UTF8-encoded error string+mkRuntimeErrorId name+ = mkVanillaGlobalWithInfo name runtimeErrorTy bottoming_info+ where+    bottoming_info = vanillaIdInfo `setStrictnessInfo`    strict_sig+                                   `setCprInfo`           mkCprSig 1 botCpr+                                   `setArityInfo`         1+                        -- Make arity and strictness agree++        -- Do *not* mark them as NoCafRefs, because they can indeed have+        -- CAF refs.  For example, pAT_ERROR_ID calls GHC.Err.untangle,+        -- which has some CAFs+        -- In due course we may arrange that these error-y things are+        -- regarded by the GC as permanently live, in which case we+        -- can give them NoCaf info.  As it is, any function that calls+        -- any pc_bottoming_Id will itself have CafRefs, which bloats+        -- SRTs.++    strict_sig = mkClosedStrictSig [evalDmd] botDiv++runtimeErrorTy :: Type+-- forall (rr :: RuntimeRep) (a :: rr). Addr# -> a+--   See Note [Error and friends have an "open-tyvar" forall]+runtimeErrorTy = mkSpecForAllTys [runtimeRep1TyVar, openAlphaTyVar]+                                 (mkVisFunTy addrPrimTy openAlphaTy)++{- Note [Error and friends have an "open-tyvar" forall]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+'error' and 'undefined' have types+        error     :: forall (v :: RuntimeRep) (a :: TYPE v). String -> a+        undefined :: forall (v :: RuntimeRep) (a :: TYPE v). a+Notice the runtime-representation polymorphism. This ensures that+"error" can be instantiated at unboxed as well as boxed types.+This is OK because it never returns, so the return type is irrelevant.+++************************************************************************+*                                                                      *+                     aBSENT_ERROR_ID+*                                                                      *+************************************************************************++Note [aBSENT_ERROR_ID]+~~~~~~~~~~~~~~~~~~~~~~+We use aBSENT_ERROR_ID to build dummy values in workers.  E.g.++   f x = (case x of (a,b) -> b) + 1::Int++The demand analyser figures ot that only the second component of x is+used, and does a w/w split thus++   f x = case x of (a,b) -> $wf b++   $wf b = let a = absentError "blah"+               x = (a,b)+           in <the original RHS of f>++After some simplification, the (absentError "blah") thunk goes away.++------ Tricky wrinkle -------+#14285 had, roughly++   data T a = MkT a !a+   {-# INLINABLE f #-}+   f x = case x of MkT a b -> g (MkT b a)++It turned out that g didn't use the second component, and hence f doesn't use+the first.  But the stable-unfolding for f looks like+   \x. case x of MkT a b -> g ($WMkT b a)+where $WMkT is the wrapper for MkT that evaluates its arguments.  We+apply the same w/w split to this unfolding (see Note [Worker-wrapper+for INLINEABLE functions] in WorkWrap) so the template ends up like+   \b. let a = absentError "blah"+           x = MkT a b+        in case x of MkT a b -> g ($WMkT b a)++After doing case-of-known-constructor, and expanding $WMkT we get+   \b -> g (case absentError "blah" of a -> MkT b a)++Yikes!  That bogusly appears to evaluate the absentError!++This is extremely tiresome.  Another way to think of this is that, in+Core, it is an invariant that a strict data constructor, like MkT, must+be applied only to an argument in HNF. So (absentError "blah") had+better be non-bottom.++So the "solution" is to add a special case for absentError to exprIsHNFlike.+This allows Simplify.rebuildCase, in the Note [Case to let transformation]+branch, to convert the case on absentError into a let. We also make+absentError *not* be diverging, unlike the other error-ids, so that we+can be sure not to remove the case branches before converting the case to+a let.++If, by some bug or bizarre happenstance, we ever call absentError, we should+throw an exception.  This should never happen, of course, but we definitely+can't return anything.  e.g. if somehow we had+    case absentError "foo" of+       Nothing -> ...+       Just x  -> ...+then if we return, the case expression will select a field and continue.+Seg fault city. Better to throw an exception. (Even though we've said+it is in HNF :-)++It might seem a bit surprising that seq on absentError is simply erased++    absentError "foo" `seq` x ==> x++but that should be okay; since there's no pattern match we can't really+be relying on anything from it.+-}++aBSENT_ERROR_ID+ = mkVanillaGlobalWithInfo absentErrorName absent_ty arity_info+ where+   absent_ty = mkSpecForAllTys [alphaTyVar] (mkVisFunTy addrPrimTy alphaTy)+   -- Not runtime-rep polymorphic. aBSENT_ERROR_ID is only used for+   -- lifted-type things; see Note [Absent errors] in WwLib+   arity_info = vanillaIdInfo `setArityInfo` 1+   -- NB: no bottoming strictness info, unlike other error-ids.+   -- See Note [aBSENT_ERROR_ID]++mkAbsentErrorApp :: Type         -- The type to instantiate 'a'+                 -> String       -- The string to print+                 -> CoreExpr++mkAbsentErrorApp res_ty err_msg+  = mkApps (Var aBSENT_ERROR_ID) [ Type res_ty, err_string ]+  where+    err_string = Lit (mkLitString err_msg)

+ compiler/GHC/Core/Map.hs view

@@ -0,0 +1,803 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+-}++{-# LANGUAGE CPP #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE UndecidableInstances #-}++module GHC.Core.Map (+   -- * Maps over Core expressions+   CoreMap, emptyCoreMap, extendCoreMap, lookupCoreMap, foldCoreMap,+   -- * Maps over 'Type's+   TypeMap, emptyTypeMap, extendTypeMap, lookupTypeMap, foldTypeMap,+   LooseTypeMap,+   -- ** With explicit scoping+   CmEnv, lookupCME, extendTypeMapWithScope, lookupTypeMapWithScope,+   mkDeBruijnContext,+   -- * Maps over 'Maybe' values+   MaybeMap,+   -- * Maps over 'List' values+   ListMap,+   -- * Maps over 'Literal's+   LiteralMap,+   -- * Map for compressing leaves. See Note [Compressed TrieMap]+   GenMap,+   -- * 'TrieMap' class+   TrieMap(..), insertTM, deleteTM,+   lkDFreeVar, xtDFreeVar,+   lkDNamed, xtDNamed,+   (>.>), (|>), (|>>),+ ) where++#include "HsVersions.h"++import GhcPrelude++import TrieMap+import GHC.Core+import Coercion+import Name+import Type+import TyCoRep+import Var+import FastString(FastString)+import Util++import qualified Data.Map    as Map+import qualified Data.IntMap as IntMap+import VarEnv+import NameEnv+import Outputable+import Control.Monad( (>=>) )++{-+This module implements TrieMaps over Core related data structures+like CoreExpr or Type. It is built on the Tries from the TrieMap+module.++The code is very regular and boilerplate-like, but there is+some neat handling of *binders*.  In effect they are deBruijn+numbered on the fly.+++-}++----------------------+-- Recall that+--   Control.Monad.(>=>) :: (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c++-- NB: Be careful about RULES and type families (#5821).  So we should make sure+-- to specify @Key TypeMapX@ (and not @DeBruijn Type@, the reduced form)++-- The CoreMap makes heavy use of GenMap. However the CoreMap Types are not+-- known when defining GenMap so we can only specialize them here.++{-# SPECIALIZE lkG :: Key TypeMapX     -> TypeMapG a     -> Maybe a #-}+{-# SPECIALIZE lkG :: Key CoercionMapX -> CoercionMapG a -> Maybe a #-}+{-# SPECIALIZE lkG :: Key CoreMapX     -> CoreMapG a     -> Maybe a #-}+++{-# SPECIALIZE xtG :: Key TypeMapX     -> XT a -> TypeMapG a -> TypeMapG a #-}+{-# SPECIALIZE xtG :: Key CoercionMapX -> XT a -> CoercionMapG a -> CoercionMapG a #-}+{-# SPECIALIZE xtG :: Key CoreMapX     -> XT a -> CoreMapG a -> CoreMapG a #-}++{-# SPECIALIZE mapG :: (a -> b) -> TypeMapG a     -> TypeMapG b #-}+{-# SPECIALIZE mapG :: (a -> b) -> CoercionMapG a -> CoercionMapG b #-}+{-# SPECIALIZE mapG :: (a -> b) -> CoreMapG a     -> CoreMapG b #-}++{-# SPECIALIZE fdG :: (a -> b -> b) -> TypeMapG a     -> b -> b #-}+{-# SPECIALIZE fdG :: (a -> b -> b) -> CoercionMapG a -> b -> b #-}+{-# SPECIALIZE fdG :: (a -> b -> b) -> CoreMapG a     -> b -> b #-}+++{-+************************************************************************+*                                                                      *+                   CoreMap+*                                                                      *+************************************************************************+-}++lkDNamed :: NamedThing n => n -> DNameEnv a -> Maybe a+lkDNamed n env = lookupDNameEnv env (getName n)++xtDNamed :: NamedThing n => n -> XT a -> DNameEnv a -> DNameEnv a+xtDNamed tc f m = alterDNameEnv f m (getName tc)+++{-+Note [Binders]+~~~~~~~~~~~~~~+ * In general we check binders as late as possible because types are+   less likely to differ than expression structure.  That's why+      cm_lam :: CoreMapG (TypeMapG a)+   rather than+      cm_lam :: TypeMapG (CoreMapG a)++ * 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++Note [Empty case alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+* For a key (Case e b ty (alt:alts))  we don't need to look the return type+  'ty', because every alternative has that type.++* For a key (Case e b ty []) we MUST look at the return type 'ty', because+  otherwise (Case (error () "urk") _ Int  []) would compare equal to+            (Case (error () "urk") _ Bool [])+  which is utterly wrong (#6097)++We could compare the return type regardless, but the wildly common case+is that it's unnecessary, so we have two fields (cm_case and cm_ecase)+for the two possibilities.  Only cm_ecase looks at the type.++See also Note [Empty case alternatives] in GHC.Core.+-}++-- | @CoreMap a@ is a map from 'CoreExpr' to @a@.  If you are a client, this+-- is the type you want.+newtype CoreMap a = CoreMap (CoreMapG a)++instance TrieMap CoreMap where+    type Key CoreMap = CoreExpr+    emptyTM = CoreMap emptyTM+    lookupTM k (CoreMap m) = lookupTM (deBruijnize k) m+    alterTM k f (CoreMap m) = CoreMap (alterTM (deBruijnize k) f m)+    foldTM k (CoreMap m) = foldTM k m+    mapTM f (CoreMap m) = CoreMap (mapTM f m)++-- | @CoreMapG a@ is a map from @DeBruijn CoreExpr@ to @a@.  The extended+-- key makes it suitable for recursive traversal, since it can track binders,+-- but it is strictly internal to this module.  If you are including a 'CoreMap'+-- inside another 'TrieMap', this is the type you want.+type CoreMapG = GenMap CoreMapX++-- | @CoreMapX a@ is the base map from @DeBruijn CoreExpr@ to @a@, but without+-- the 'GenMap' optimization.+data CoreMapX a+  = CM { cm_var   :: VarMap a+       , cm_lit   :: LiteralMap a+       , cm_co    :: CoercionMapG a+       , cm_type  :: TypeMapG a+       , cm_cast  :: CoreMapG (CoercionMapG a)+       , cm_tick  :: CoreMapG (TickishMap a)+       , cm_app   :: CoreMapG (CoreMapG a)+       , cm_lam   :: CoreMapG (BndrMap a)    -- Note [Binders]+       , cm_letn  :: CoreMapG (CoreMapG (BndrMap a))+       , cm_letr  :: ListMap CoreMapG (CoreMapG (ListMap BndrMap a))+       , cm_case  :: CoreMapG (ListMap AltMap a)+       , cm_ecase :: CoreMapG (TypeMapG a)    -- Note [Empty case alternatives]+     }++instance Eq (DeBruijn CoreExpr) where+  D env1 e1 == D env2 e2 = go e1 e2 where+    go (Var v1) (Var v2) = case (lookupCME env1 v1, lookupCME env2 v2) of+                            (Just b1, Just b2) -> b1 == b2+                            (Nothing, Nothing) -> v1 == v2+                            _ -> False+    go (Lit lit1)    (Lit lit2)      = lit1 == lit2+    go (Type t1)    (Type t2)        = D env1 t1 == D env2 t2+    go (Coercion co1) (Coercion co2) = D env1 co1 == D env2 co2+    go (Cast e1 co1) (Cast e2 co2) = D env1 co1 == D env2 co2 && go e1 e2+    go (App f1 a1)   (App f2 a2)   = go f1 f2 && go a1 a2+    -- This seems a bit dodgy, see 'eqTickish'+    go (Tick n1 e1)  (Tick n2 e2)  = n1 == n2 && go e1 e2++    go (Lam b1 e1)  (Lam b2 e2)+      =  D env1 (varType b1) == D env2 (varType b2)+      && D (extendCME env1 b1) e1 == D (extendCME env2 b2) e2++    go (Let (NonRec v1 r1) e1) (Let (NonRec v2 r2) e2)+      =  go r1 r2+      && D (extendCME env1 v1) e1 == D (extendCME env2 v2) e2++    go (Let (Rec ps1) e1) (Let (Rec ps2) e2)+      = equalLength ps1 ps2+      && D env1' rs1 == D env2' rs2+      && D env1' e1  == D env2' e2+      where+        (bs1,rs1) = unzip ps1+        (bs2,rs2) = unzip ps2+        env1' = extendCMEs env1 bs1+        env2' = extendCMEs env2 bs2++    go (Case e1 b1 t1 a1) (Case e2 b2 t2 a2)+      | null a1   -- See Note [Empty case alternatives]+      = null a2 && go e1 e2 && D env1 t1 == D env2 t2+      | otherwise+      =  go e1 e2 && D (extendCME env1 b1) a1 == D (extendCME env2 b2) a2++    go _ _ = False++emptyE :: CoreMapX a+emptyE = CM { cm_var = emptyTM, cm_lit = emptyTM+            , cm_co = emptyTM, cm_type = emptyTM+            , cm_cast = emptyTM, cm_app = emptyTM+            , cm_lam = emptyTM, cm_letn = emptyTM+            , cm_letr = emptyTM, cm_case = emptyTM+            , cm_ecase = emptyTM, cm_tick = emptyTM }++instance TrieMap CoreMapX where+   type Key CoreMapX = DeBruijn CoreExpr+   emptyTM  = emptyE+   lookupTM = lkE+   alterTM  = xtE+   foldTM   = fdE+   mapTM    = mapE++--------------------------+mapE :: (a->b) -> CoreMapX a -> CoreMapX b+mapE f (CM { cm_var = cvar, cm_lit = clit+           , cm_co = cco, cm_type = ctype+           , cm_cast = ccast , cm_app = capp+           , cm_lam = clam, cm_letn = cletn+           , cm_letr = cletr, cm_case = ccase+           , cm_ecase = cecase, cm_tick = ctick })+  = CM { cm_var = mapTM f cvar, cm_lit = mapTM f clit+       , cm_co = mapTM f cco, cm_type = mapTM f ctype+       , cm_cast = mapTM (mapTM f) ccast, cm_app = mapTM (mapTM f) capp+       , cm_lam = mapTM (mapTM f) clam, cm_letn = mapTM (mapTM (mapTM f)) cletn+       , cm_letr = mapTM (mapTM (mapTM f)) cletr, cm_case = mapTM (mapTM f) ccase+       , cm_ecase = mapTM (mapTM f) cecase, cm_tick = mapTM (mapTM f) ctick }++--------------------------+lookupCoreMap :: CoreMap a -> CoreExpr -> Maybe a+lookupCoreMap cm e = lookupTM e cm++extendCoreMap :: CoreMap a -> CoreExpr -> a -> CoreMap a+extendCoreMap m e v = alterTM e (\_ -> Just v) m++foldCoreMap :: (a -> b -> b) -> b -> CoreMap a -> b+foldCoreMap k z m = foldTM k m z++emptyCoreMap :: CoreMap a+emptyCoreMap = emptyTM++instance Outputable a => Outputable (CoreMap a) where+  ppr m = text "CoreMap elts" <+> ppr (foldTM (:) m [])++-------------------------+fdE :: (a -> b -> b) -> CoreMapX a -> b -> b+fdE k m+  = foldTM k (cm_var m)+  . foldTM k (cm_lit m)+  . foldTM k (cm_co m)+  . foldTM k (cm_type m)+  . foldTM (foldTM k) (cm_cast m)+  . foldTM (foldTM k) (cm_tick m)+  . foldTM (foldTM k) (cm_app m)+  . foldTM (foldTM k) (cm_lam m)+  . foldTM (foldTM (foldTM k)) (cm_letn m)+  . foldTM (foldTM (foldTM k)) (cm_letr m)+  . foldTM (foldTM k) (cm_case m)+  . foldTM (foldTM k) (cm_ecase m)++-- lkE: lookup in trie for expressions+lkE :: DeBruijn CoreExpr -> CoreMapX a -> Maybe a+lkE (D env expr) cm = go expr cm+  where+    go (Var v)              = cm_var  >.> lkVar env v+    go (Lit l)              = cm_lit  >.> lookupTM l+    go (Type t)             = cm_type >.> lkG (D env t)+    go (Coercion c)         = cm_co   >.> lkG (D env c)+    go (Cast e c)           = cm_cast >.> lkG (D env e) >=> lkG (D env c)+    go (Tick tickish e)     = cm_tick >.> lkG (D env e) >=> lkTickish tickish+    go (App e1 e2)          = cm_app  >.> lkG (D env e2) >=> lkG (D env e1)+    go (Lam v e)            = cm_lam  >.> lkG (D (extendCME env v) e)+                              >=> lkBndr env v+    go (Let (NonRec b r) e) = cm_letn >.> lkG (D env r)+                              >=> lkG (D (extendCME env b) e) >=> lkBndr env b+    go (Let (Rec prs) e)    = let (bndrs,rhss) = unzip prs+                                  env1 = extendCMEs env bndrs+                              in cm_letr+                                 >.> lkList (lkG . D env1) rhss+                                 >=> lkG (D env1 e)+                                 >=> lkList (lkBndr env1) bndrs+    go (Case e b ty as)     -- See Note [Empty case alternatives]+               | null as    = cm_ecase >.> lkG (D env e) >=> lkG (D env ty)+               | otherwise  = cm_case >.> lkG (D env e)+                              >=> lkList (lkA (extendCME env b)) as++xtE :: DeBruijn CoreExpr -> XT a -> CoreMapX a -> CoreMapX a+xtE (D env (Var v))              f m = m { cm_var  = cm_var m+                                                 |> xtVar env v f }+xtE (D env (Type t))             f m = m { cm_type = cm_type m+                                                 |> xtG (D env t) f }+xtE (D env (Coercion c))         f m = m { cm_co   = cm_co m+                                                 |> xtG (D env c) f }+xtE (D _   (Lit l))              f m = m { cm_lit  = cm_lit m  |> alterTM l f }+xtE (D env (Cast e c))           f m = m { cm_cast = cm_cast m |> xtG (D env e)+                                                 |>> xtG (D env c) f }+xtE (D env (Tick t e))           f m = m { cm_tick = cm_tick m |> xtG (D env e)+                                                 |>> xtTickish t f }+xtE (D env (App e1 e2))          f m = m { cm_app = cm_app m |> xtG (D env e2)+                                                 |>> xtG (D env e1) f }+xtE (D env (Lam v e))            f m = m { cm_lam = cm_lam m+                                                 |> xtG (D (extendCME env v) e)+                                                 |>> xtBndr env v f }+xtE (D env (Let (NonRec b r) e)) f m = m { cm_letn = cm_letn m+                                                 |> xtG (D (extendCME env b) e)+                                                 |>> xtG (D env r)+                                                 |>> xtBndr env b f }+xtE (D env (Let (Rec prs) e))    f m = m { cm_letr =+                                              let (bndrs,rhss) = unzip prs+                                                  env1 = extendCMEs env bndrs+                                              in cm_letr m+                                                 |>  xtList (xtG . D env1) rhss+                                                 |>> xtG (D env1 e)+                                                 |>> xtList (xtBndr env1)+                                                            bndrs f }+xtE (D env (Case e b ty as))     f m+                     | null as   = m { cm_ecase = cm_ecase m |> xtG (D env e)+                                                 |>> xtG (D env ty) f }+                     | otherwise = m { cm_case = cm_case m |> xtG (D env e)+                                                 |>> let env1 = extendCME env b+                                                     in xtList (xtA env1) as f }++-- TODO: this seems a bit dodgy, see 'eqTickish'+type TickishMap a = Map.Map (Tickish Id) a+lkTickish :: Tickish Id -> TickishMap a -> Maybe a+lkTickish = lookupTM++xtTickish :: Tickish Id -> XT a -> TickishMap a -> TickishMap a+xtTickish = alterTM++------------------------+data AltMap a   -- A single alternative+  = AM { am_deflt :: CoreMapG a+       , am_data  :: DNameEnv (CoreMapG a)+       , am_lit   :: LiteralMap (CoreMapG a) }++instance TrieMap AltMap where+   type Key AltMap = CoreAlt+   emptyTM  = AM { am_deflt = emptyTM+                 , am_data = emptyDNameEnv+                 , am_lit  = emptyTM }+   lookupTM = lkA emptyCME+   alterTM  = xtA emptyCME+   foldTM   = fdA+   mapTM    = mapA++instance Eq (DeBruijn CoreAlt) where+  D env1 a1 == D env2 a2 = go a1 a2 where+    go (DEFAULT, _, rhs1) (DEFAULT, _, rhs2)+        = D env1 rhs1 == D env2 rhs2+    go (LitAlt lit1, _, rhs1) (LitAlt lit2, _, rhs2)+        = lit1 == lit2 && D env1 rhs1 == D env2 rhs2+    go (DataAlt dc1, bs1, rhs1) (DataAlt dc2, bs2, rhs2)+        = dc1 == dc2 &&+          D (extendCMEs env1 bs1) rhs1 == D (extendCMEs env2 bs2) rhs2+    go _ _ = False++mapA :: (a->b) -> AltMap a -> AltMap b+mapA f (AM { am_deflt = adeflt, am_data = adata, am_lit = alit })+  = AM { am_deflt = mapTM f adeflt+       , am_data = mapTM (mapTM f) adata+       , am_lit = mapTM (mapTM f) alit }++lkA :: CmEnv -> CoreAlt -> AltMap a -> Maybe a+lkA env (DEFAULT,    _, rhs)  = am_deflt >.> lkG (D env rhs)+lkA env (LitAlt lit, _, rhs)  = am_lit >.> lookupTM lit >=> lkG (D env rhs)+lkA env (DataAlt dc, bs, rhs) = am_data >.> lkDNamed dc+                                        >=> lkG (D (extendCMEs env bs) rhs)++xtA :: CmEnv -> CoreAlt -> XT a -> AltMap a -> AltMap a+xtA env (DEFAULT, _, rhs)    f m =+    m { am_deflt = am_deflt m |> xtG (D env rhs) f }+xtA env (LitAlt l, _, rhs)   f m =+    m { am_lit   = am_lit m   |> alterTM l |>> xtG (D env rhs) f }+xtA env (DataAlt d, bs, rhs) f m =+    m { am_data  = am_data m  |> xtDNamed d+                             |>> xtG (D (extendCMEs env bs) rhs) f }++fdA :: (a -> b -> b) -> AltMap a -> b -> b+fdA k m = foldTM k (am_deflt m)+        . foldTM (foldTM k) (am_data m)+        . foldTM (foldTM k) (am_lit m)++{-+************************************************************************+*                                                                      *+                   Coercions+*                                                                      *+************************************************************************+-}++-- We should really never care about the contents of a coercion. Instead,+-- just look up the coercion's type.+newtype CoercionMap a = CoercionMap (CoercionMapG a)++instance TrieMap CoercionMap where+   type Key CoercionMap = Coercion+   emptyTM                     = CoercionMap emptyTM+   lookupTM k  (CoercionMap m) = lookupTM (deBruijnize k) m+   alterTM k f (CoercionMap m) = CoercionMap (alterTM (deBruijnize k) f m)+   foldTM k    (CoercionMap m) = foldTM k m+   mapTM f     (CoercionMap m) = CoercionMap (mapTM f m)++type CoercionMapG = GenMap CoercionMapX+newtype CoercionMapX a = CoercionMapX (TypeMapX a)++instance TrieMap CoercionMapX where+  type Key CoercionMapX = DeBruijn Coercion+  emptyTM = CoercionMapX emptyTM+  lookupTM = lkC+  alterTM  = xtC+  foldTM f (CoercionMapX core_tm) = foldTM f core_tm+  mapTM f (CoercionMapX core_tm)  = CoercionMapX (mapTM f core_tm)++instance Eq (DeBruijn Coercion) where+  D env1 co1 == D env2 co2+    = D env1 (coercionType co1) ==+      D env2 (coercionType co2)++lkC :: DeBruijn Coercion -> CoercionMapX a -> Maybe a+lkC (D env co) (CoercionMapX core_tm) = lkT (D env $ coercionType co)+                                        core_tm++xtC :: DeBruijn Coercion -> XT a -> CoercionMapX a -> CoercionMapX a+xtC (D env co) f (CoercionMapX m)+  = CoercionMapX (xtT (D env $ coercionType co) f m)++{-+************************************************************************+*                                                                      *+                   Types+*                                                                      *+************************************************************************+-}++-- | @TypeMapG a@ is a map from @DeBruijn Type@ to @a@.  The extended+-- key makes it suitable for recursive traversal, since it can track binders,+-- but it is strictly internal to this module.  If you are including a 'TypeMap'+-- inside another 'TrieMap', this is the type you want. Note that this+-- lookup does not do a kind-check. Thus, all keys in this map must have+-- the same kind. Also note that this map respects the distinction between+-- @Type@ and @Constraint@, despite the fact that they are equivalent type+-- synonyms in Core.+type TypeMapG = GenMap TypeMapX++-- | @TypeMapX a@ is the base map from @DeBruijn Type@ to @a@, but without the+-- 'GenMap' optimization.+data TypeMapX a+  = TM { tm_var    :: VarMap a+       , tm_app    :: TypeMapG (TypeMapG a)+       , tm_tycon  :: DNameEnv a+       , tm_forall :: TypeMapG (BndrMap a) -- See Note [Binders]+       , tm_tylit  :: TyLitMap a+       , tm_coerce :: Maybe a+       }+    -- Note that there is no tyconapp case; see Note [Equality on AppTys] in Type++-- | Squeeze out any synonyms, and change TyConApps to nested AppTys. Why the+-- last one? See Note [Equality on AppTys] in Type+--+-- Note, however, that we keep Constraint and Type apart here, despite the fact+-- that they are both synonyms of TYPE 'LiftedRep (see #11715).+trieMapView :: Type -> Maybe Type+trieMapView ty+  -- First check for TyConApps that need to be expanded to+  -- AppTy chains.+  | Just (tc, tys@(_:_)) <- tcSplitTyConApp_maybe ty+  = Just $ foldl' AppTy (TyConApp tc []) tys++  -- Then resolve any remaining nullary synonyms.+  | Just ty' <- tcView ty = Just ty'+trieMapView _ = Nothing++instance TrieMap TypeMapX where+   type Key TypeMapX = DeBruijn Type+   emptyTM  = emptyT+   lookupTM = lkT+   alterTM  = xtT+   foldTM   = fdT+   mapTM    = mapT++instance Eq (DeBruijn Type) where+  env_t@(D env t) == env_t'@(D env' t')+    | Just new_t  <- tcView t  = D env new_t == env_t'+    | Just new_t' <- tcView t' = env_t       == D env' new_t'+    | otherwise+    = case (t, t') of+        (CastTy t1 _, _)  -> D env t1 == D env t'+        (_, CastTy t1' _) -> D env t  == D env t1'++        (TyVarTy v, TyVarTy v')+            -> case (lookupCME env v, lookupCME env' v') of+                (Just bv, Just bv') -> bv == bv'+                (Nothing, Nothing)  -> v == v'+                _ -> False+                -- See Note [Equality on AppTys] in Type+        (AppTy t1 t2, s) | Just (t1', t2') <- repSplitAppTy_maybe s+            -> D env t1 == D env' t1' && D env t2 == D env' t2'+        (s, AppTy t1' t2') | Just (t1, t2) <- repSplitAppTy_maybe s+            -> D env t1 == D env' t1' && D env t2 == D env' t2'+        (FunTy _ t1 t2, FunTy _ t1' t2')+            -> D env t1 == D env' t1' && D env t2 == D env' t2'+        (TyConApp tc tys, TyConApp tc' tys')+            -> tc == tc' && D env tys == D env' tys'+        (LitTy l, LitTy l')+            -> l == l'+        (ForAllTy (Bndr tv _) ty, ForAllTy (Bndr tv' _) ty')+            -> D env (varType tv)      == D env' (varType tv') &&+               D (extendCME env tv) ty == D (extendCME env' tv') ty'+        (CoercionTy {}, CoercionTy {})+            -> True+        _ -> False++instance {-# OVERLAPPING #-}+         Outputable a => Outputable (TypeMapG a) where+  ppr m = text "TypeMap elts" <+> ppr (foldTM (:) m [])++emptyT :: TypeMapX a+emptyT = TM { tm_var  = emptyTM+            , tm_app  = emptyTM+            , tm_tycon  = emptyDNameEnv+            , tm_forall = emptyTM+            , tm_tylit  = emptyTyLitMap+            , tm_coerce = Nothing }++mapT :: (a->b) -> TypeMapX a -> TypeMapX b+mapT f (TM { tm_var  = tvar, tm_app = tapp, tm_tycon = ttycon+           , tm_forall = tforall, tm_tylit = tlit+           , tm_coerce = tcoerce })+  = TM { tm_var    = mapTM f tvar+       , tm_app    = mapTM (mapTM f) tapp+       , tm_tycon  = mapTM f ttycon+       , tm_forall = mapTM (mapTM f) tforall+       , tm_tylit  = mapTM f tlit+       , tm_coerce = fmap f tcoerce }++-----------------+lkT :: DeBruijn Type -> TypeMapX a -> Maybe a+lkT (D env ty) m = go ty m+  where+    go ty | Just ty' <- trieMapView ty = go ty'+    go (TyVarTy v)                 = tm_var    >.> lkVar env v+    go (AppTy t1 t2)               = tm_app    >.> lkG (D env t1)+                                               >=> lkG (D env t2)+    go (TyConApp tc [])            = tm_tycon  >.> lkDNamed tc+    go ty@(TyConApp _ (_:_))       = pprPanic "lkT TyConApp" (ppr ty)+    go (LitTy l)                   = tm_tylit  >.> lkTyLit l+    go (ForAllTy (Bndr tv _) ty)   = tm_forall >.> lkG (D (extendCME env tv) ty)+                                               >=> lkBndr env tv+    go ty@(FunTy {})               = pprPanic "lkT FunTy" (ppr ty)+    go (CastTy t _)                = go t+    go (CoercionTy {})             = tm_coerce++-----------------+xtT :: DeBruijn Type -> XT a -> TypeMapX a -> TypeMapX a+xtT (D env ty) f m | Just ty' <- trieMapView ty = xtT (D env ty') f m++xtT (D env (TyVarTy v))       f m = m { tm_var    = tm_var m |> xtVar env v f }+xtT (D env (AppTy t1 t2))     f m = m { tm_app    = tm_app m |> xtG (D env t1)+                                                            |>> xtG (D env t2) f }+xtT (D _   (TyConApp tc []))  f m = m { tm_tycon  = tm_tycon m |> xtDNamed tc f }+xtT (D _   (LitTy l))         f m = m { tm_tylit  = tm_tylit m |> xtTyLit l f }+xtT (D env (CastTy t _))      f m = xtT (D env t) f m+xtT (D _   (CoercionTy {}))   f m = m { tm_coerce = tm_coerce m |> f }+xtT (D env (ForAllTy (Bndr tv _) ty))  f m+  = m { tm_forall = tm_forall m |> xtG (D (extendCME env tv) ty)+                                |>> xtBndr env tv f }+xtT (D _   ty@(TyConApp _ (_:_))) _ _ = pprPanic "xtT TyConApp" (ppr ty)+xtT (D _   ty@(FunTy {}))         _ _ = pprPanic "xtT FunTy" (ppr ty)++fdT :: (a -> b -> b) -> TypeMapX a -> b -> b+fdT k m = foldTM k (tm_var m)+        . foldTM (foldTM k) (tm_app m)+        . foldTM k (tm_tycon m)+        . foldTM (foldTM k) (tm_forall m)+        . foldTyLit k (tm_tylit m)+        . foldMaybe k (tm_coerce m)++------------------------+data TyLitMap a = TLM { tlm_number :: Map.Map Integer a+                      , tlm_string :: Map.Map FastString a+                      }++instance TrieMap TyLitMap where+   type Key TyLitMap = TyLit+   emptyTM  = emptyTyLitMap+   lookupTM = lkTyLit+   alterTM  = xtTyLit+   foldTM   = foldTyLit+   mapTM    = mapTyLit++emptyTyLitMap :: TyLitMap a+emptyTyLitMap = TLM { tlm_number = Map.empty, tlm_string = Map.empty }++mapTyLit :: (a->b) -> TyLitMap a -> TyLitMap b+mapTyLit f (TLM { tlm_number = tn, tlm_string = ts })+  = TLM { tlm_number = Map.map f tn, tlm_string = Map.map f ts }++lkTyLit :: TyLit -> TyLitMap a -> Maybe a+lkTyLit l =+  case l of+    NumTyLit n -> tlm_number >.> Map.lookup n+    StrTyLit n -> tlm_string >.> Map.lookup n++xtTyLit :: TyLit -> XT a -> TyLitMap a -> TyLitMap a+xtTyLit l f m =+  case l of+    NumTyLit n -> m { tlm_number = tlm_number m |> Map.alter f n }+    StrTyLit n -> m { tlm_string = tlm_string m |> Map.alter f n }++foldTyLit :: (a -> b -> b) -> TyLitMap a -> b -> b+foldTyLit l m = flip (Map.foldr l) (tlm_string m)+              . flip (Map.foldr l) (tlm_number m)++-------------------------------------------------+-- | @TypeMap a@ is a map from 'Type' to @a@.  If you are a client, this+-- is the type you want. The keys in this map may have different kinds.+newtype TypeMap a = TypeMap (TypeMapG (TypeMapG a))++lkTT :: DeBruijn Type -> TypeMap a -> Maybe a+lkTT (D env ty) (TypeMap m) = lkG (D env $ typeKind ty) m+                          >>= lkG (D env ty)++xtTT :: DeBruijn Type -> XT a -> TypeMap a -> TypeMap a+xtTT (D env ty) f (TypeMap m)+  = TypeMap (m |> xtG (D env $ typeKind ty)+               |>> xtG (D env ty) f)++-- Below are some client-oriented functions which operate on 'TypeMap'.++instance TrieMap TypeMap where+    type Key TypeMap = Type+    emptyTM = TypeMap emptyTM+    lookupTM k m = lkTT (deBruijnize k) m+    alterTM k f m = xtTT (deBruijnize k) f m+    foldTM k (TypeMap m) = foldTM (foldTM k) m+    mapTM f (TypeMap m) = TypeMap (mapTM (mapTM f) m)++foldTypeMap :: (a -> b -> b) -> b -> TypeMap a -> b+foldTypeMap k z m = foldTM k m z++emptyTypeMap :: TypeMap a+emptyTypeMap = emptyTM++lookupTypeMap :: TypeMap a -> Type -> Maybe a+lookupTypeMap cm t = lookupTM t cm++extendTypeMap :: TypeMap a -> Type -> a -> TypeMap a+extendTypeMap m t v = alterTM t (const (Just v)) m++lookupTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> Maybe a+lookupTypeMapWithScope m cm t = lkTT (D cm t) m++-- | Extend a 'TypeMap' with a type in the given context.+-- @extendTypeMapWithScope m (mkDeBruijnContext [a,b,c]) t v@ is equivalent to+-- @extendTypeMap m (forall a b c. t) v@, but allows reuse of the context over+-- multiple insertions.+extendTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> a -> TypeMap a+extendTypeMapWithScope m cm t v = xtTT (D cm t) (const (Just v)) m++-- | Construct a deBruijn environment with the given variables in scope.+-- e.g. @mkDeBruijnEnv [a,b,c]@ constructs a context @forall a b c.@+mkDeBruijnContext :: [Var] -> CmEnv+mkDeBruijnContext = extendCMEs emptyCME++-- | A 'LooseTypeMap' doesn't do a kind-check. Thus, when lookup up (t |> g),+-- you'll find entries inserted under (t), even if (g) is non-reflexive.+newtype LooseTypeMap a+  = LooseTypeMap (TypeMapG a)++instance TrieMap LooseTypeMap where+  type Key LooseTypeMap = Type+  emptyTM = LooseTypeMap emptyTM+  lookupTM k (LooseTypeMap m) = lookupTM (deBruijnize k) m+  alterTM k f (LooseTypeMap m) = LooseTypeMap (alterTM (deBruijnize k) f m)+  foldTM f (LooseTypeMap m) = foldTM f m+  mapTM f (LooseTypeMap m) = LooseTypeMap (mapTM f m)++{-+************************************************************************+*                                                                      *+                   Variables+*                                                                      *+************************************************************************+-}++type BoundVar = Int  -- Bound variables are deBruijn numbered+type BoundVarMap a = IntMap.IntMap a++data CmEnv = CME { cme_next :: !BoundVar+                 , cme_env  :: VarEnv BoundVar }++emptyCME :: CmEnv+emptyCME = CME { cme_next = 0, cme_env = emptyVarEnv }++extendCME :: CmEnv -> Var -> CmEnv+extendCME (CME { cme_next = bv, cme_env = env }) v+  = CME { cme_next = bv+1, cme_env = extendVarEnv env v bv }++extendCMEs :: CmEnv -> [Var] -> CmEnv+extendCMEs env vs = foldl' extendCME env vs++lookupCME :: CmEnv -> Var -> Maybe BoundVar+lookupCME (CME { cme_env = env }) v = lookupVarEnv env v++-- | @DeBruijn a@ represents @a@ modulo alpha-renaming.  This is achieved+-- by equipping the value with a 'CmEnv', which tracks an on-the-fly deBruijn+-- numbering.  This allows us to define an 'Eq' instance for @DeBruijn a@, even+-- if this was not (easily) possible for @a@.  Note: we purposely don't+-- export the constructor.  Make a helper function if you find yourself+-- needing it.+data DeBruijn a = D CmEnv a++-- | Synthesizes a @DeBruijn a@ from an @a@, by assuming that there are no+-- bound binders (an empty 'CmEnv').  This is usually what you want if there+-- isn't already a 'CmEnv' in scope.+deBruijnize :: a -> DeBruijn a+deBruijnize = D emptyCME++instance Eq (DeBruijn a) => Eq (DeBruijn [a]) where+    D _   []     == D _    []       = True+    D env (x:xs) == D env' (x':xs') = D env x  == D env' x' &&+                                      D env xs == D env' xs'+    _            == _               = False++--------- Variable binders -------------++-- | A 'BndrMap' is a 'TypeMapG' which allows us to distinguish between+-- binding forms whose binders have different types.  For example,+-- if we are doing a 'TrieMap' lookup on @\(x :: Int) -> ()@, we should+-- not pick up an entry in the 'TrieMap' for @\(x :: Bool) -> ()@:+-- we can disambiguate this by matching on the type (or kind, if this+-- a binder in a type) of the binder.+type BndrMap = TypeMapG++-- Note [Binders]+-- ~~~~~~~~~~~~~~+-- We need to use 'BndrMap' for 'Coercion', 'CoreExpr' AND 'Type', since all+-- of these data types have binding forms.++lkBndr :: CmEnv -> Var -> BndrMap a -> Maybe a+lkBndr env v m = lkG (D env (varType v)) m++xtBndr :: CmEnv -> Var -> XT a -> BndrMap a -> BndrMap a+xtBndr env v f = xtG (D env (varType v)) f++--------- Variable occurrence -------------+data VarMap a = VM { vm_bvar   :: BoundVarMap a  -- Bound variable+                   , vm_fvar   :: DVarEnv a }      -- Free variable++instance TrieMap VarMap where+   type Key VarMap = Var+   emptyTM  = VM { vm_bvar = IntMap.empty, vm_fvar = emptyDVarEnv }+   lookupTM = lkVar emptyCME+   alterTM  = xtVar emptyCME+   foldTM   = fdVar+   mapTM    = mapVar++mapVar :: (a->b) -> VarMap a -> VarMap b+mapVar f (VM { vm_bvar = bv, vm_fvar = fv })+  = VM { vm_bvar = mapTM f bv, vm_fvar = mapTM f fv }++lkVar :: CmEnv -> Var -> VarMap a -> Maybe a+lkVar env v+  | Just bv <- lookupCME env v = vm_bvar >.> lookupTM bv+  | otherwise                  = vm_fvar >.> lkDFreeVar v++xtVar :: CmEnv -> Var -> XT a -> VarMap a -> VarMap a+xtVar env v f m+  | Just bv <- lookupCME env v = m { vm_bvar = vm_bvar m |> alterTM bv f }+  | otherwise                  = m { vm_fvar = vm_fvar m |> xtDFreeVar v f }++fdVar :: (a -> b -> b) -> VarMap a -> b -> b+fdVar k m = foldTM k (vm_bvar m)+          . foldTM k (vm_fvar m)++lkDFreeVar :: Var -> DVarEnv a -> Maybe a+lkDFreeVar var env = lookupDVarEnv env var++xtDFreeVar :: Var -> XT a -> DVarEnv a -> DVarEnv a+xtDFreeVar v f m = alterDVarEnv f m v

+ compiler/GHC/Core/Op/Tidy.hs view

@@ -0,0 +1,286 @@+{-+(c) The University of Glasgow 2006+(c) The AQUA Project, Glasgow University, 1996-1998+++This module contains "tidying" code for *nested* expressions, bindings, rules.+The code for *top-level* bindings is in GHC.Iface.Tidy.+-}++{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}+module GHC.Core.Op.Tidy (+        tidyExpr, tidyRules, tidyUnfolding+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Core+import GHC.Core.Seq ( seqUnfolding )+import Id+import IdInfo+import Demand ( zapUsageEnvSig )+import Type( tidyType, tidyVarBndr )+import Coercion( tidyCo )+import Var+import VarEnv+import UniqFM+import Name hiding (tidyNameOcc)+import SrcLoc+import Maybes+import Data.List++{-+************************************************************************+*                                                                      *+\subsection{Tidying expressions, rules}+*                                                                      *+************************************************************************+-}++tidyBind :: TidyEnv+         -> CoreBind+         ->  (TidyEnv, CoreBind)++tidyBind env (NonRec bndr rhs)+  = tidyLetBndr env env bndr =: \ (env', bndr') ->+    (env', NonRec bndr' (tidyExpr env' rhs))++tidyBind env (Rec prs)+  = let+       (bndrs, rhss)  = unzip prs+       (env', bndrs') = mapAccumL (tidyLetBndr env') env bndrs+    in+    map (tidyExpr env') rhss =: \ rhss' ->+    (env', Rec (zip bndrs' rhss'))+++------------  Expressions  --------------+tidyExpr :: TidyEnv -> CoreExpr -> CoreExpr+tidyExpr env (Var v)       = Var (tidyVarOcc env v)+tidyExpr env (Type ty)     = Type (tidyType env ty)+tidyExpr env (Coercion co) = Coercion (tidyCo env co)+tidyExpr _   (Lit lit)     = Lit lit+tidyExpr env (App f a)     = App (tidyExpr env f) (tidyExpr env a)+tidyExpr env (Tick t e)    = Tick (tidyTickish env t) (tidyExpr env e)+tidyExpr env (Cast e co)   = Cast (tidyExpr env e) (tidyCo env co)++tidyExpr env (Let b e)+  = tidyBind env b      =: \ (env', b') ->+    Let b' (tidyExpr env' e)++tidyExpr env (Case e b ty alts)+  = tidyBndr env b  =: \ (env', b) ->+    Case (tidyExpr env e) b (tidyType env ty)+         (map (tidyAlt env') alts)++tidyExpr env (Lam b e)+  = tidyBndr env b      =: \ (env', b) ->+    Lam b (tidyExpr env' e)++------------  Case alternatives  --------------+tidyAlt :: TidyEnv -> CoreAlt -> CoreAlt+tidyAlt env (con, vs, rhs)+  = tidyBndrs env vs    =: \ (env', vs) ->+    (con, vs, tidyExpr env' rhs)++------------  Tickish  --------------+tidyTickish :: TidyEnv -> Tickish Id -> Tickish Id+tidyTickish env (Breakpoint ix ids) = Breakpoint ix (map (tidyVarOcc env) ids)+tidyTickish _   other_tickish       = other_tickish++------------  Rules  --------------+tidyRules :: TidyEnv -> [CoreRule] -> [CoreRule]+tidyRules _   [] = []+tidyRules env (rule : rules)+  = tidyRule env rule           =: \ rule ->+    tidyRules env rules         =: \ rules ->+    (rule : rules)++tidyRule :: TidyEnv -> CoreRule -> CoreRule+tidyRule _   rule@(BuiltinRule {}) = rule+tidyRule env rule@(Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs,+                          ru_fn = fn, ru_rough = mb_ns })+  = tidyBndrs env bndrs         =: \ (env', bndrs) ->+    map (tidyExpr env') args    =: \ args ->+    rule { ru_bndrs = bndrs, ru_args = args,+           ru_rhs   = tidyExpr env' rhs,+           ru_fn    = tidyNameOcc env fn,+           ru_rough = map (fmap (tidyNameOcc env')) mb_ns }++{-+************************************************************************+*                                                                      *+\subsection{Tidying non-top-level binders}+*                                                                      *+************************************************************************+-}++tidyNameOcc :: TidyEnv -> Name -> Name+-- In rules and instances, we have Names, and we must tidy them too+-- Fortunately, we can lookup in the VarEnv with a name+tidyNameOcc (_, var_env) n = case lookupUFM var_env n of+                                Nothing -> n+                                Just v  -> idName v++tidyVarOcc :: TidyEnv -> Var -> Var+tidyVarOcc (_, var_env) v = lookupVarEnv var_env v `orElse` v++-- tidyBndr is used for lambda and case binders+tidyBndr :: TidyEnv -> Var -> (TidyEnv, Var)+tidyBndr env var+  | isTyCoVar var = tidyVarBndr env var+  | otherwise     = tidyIdBndr env var++tidyBndrs :: TidyEnv -> [Var] -> (TidyEnv, [Var])+tidyBndrs env vars = mapAccumL tidyBndr env vars++-- Non-top-level variables, not covars+tidyIdBndr :: TidyEnv -> Id -> (TidyEnv, Id)+tidyIdBndr env@(tidy_env, var_env) id+  = -- Do this pattern match strictly, otherwise we end up holding on to+    -- stuff in the OccName.+    case tidyOccName tidy_env (getOccName id) of { (tidy_env', occ') ->+    let+        -- Give the Id a fresh print-name, *and* rename its type+        -- The SrcLoc isn't important now,+        -- though we could extract it from the Id+        --+        ty'      = tidyType env (idType id)+        name'    = mkInternalName (idUnique id) occ' noSrcSpan+        id'      = mkLocalIdWithInfo name' ty' new_info+        var_env' = extendVarEnv var_env id id'++        -- Note [Tidy IdInfo]+        new_info = vanillaIdInfo `setOccInfo` occInfo old_info+                                 `setUnfoldingInfo` new_unf+                                  -- see Note [Preserve OneShotInfo]+                                 `setOneShotInfo` oneShotInfo old_info+        old_info = idInfo id+        old_unf  = unfoldingInfo old_info+        new_unf  = zapUnfolding old_unf  -- See Note [Preserve evaluatedness]+    in+    ((tidy_env', var_env'), id')+   }++tidyLetBndr :: TidyEnv         -- Knot-tied version for unfoldings+            -> TidyEnv         -- The one to extend+            -> Id -> (TidyEnv, Id)+-- Used for local (non-top-level) let(rec)s+-- Just like tidyIdBndr above, but with more IdInfo+tidyLetBndr rec_tidy_env env@(tidy_env, var_env) id+  = case tidyOccName tidy_env (getOccName id) of { (tidy_env', occ') ->+    let+        ty'      = tidyType env (idType id)+        name'    = mkInternalName (idUnique id) occ' noSrcSpan+        details  = idDetails id+        id'      = mkLocalVar details name' ty' new_info+        var_env' = extendVarEnv var_env id id'++        -- Note [Tidy IdInfo]+        -- We need to keep around any interesting strictness and+        -- demand info because later on we may need to use it when+        -- converting to A-normal form.+        -- eg.+        --      f (g x),  where f is strict in its argument, will be converted+        --      into  case (g x) of z -> f z  by CorePrep, but only if f still+        --      has its strictness info.+        --+        -- Similarly for the demand info - on a let binder, this tells+        -- CorePrep to turn the let into a case.+        -- But: Remove the usage demand here+        --      (See Note [Zapping DmdEnv after Demand Analyzer] in WorkWrap)+        --+        -- Similarly arity info for eta expansion in CorePrep+        -- Don't attempt to recompute arity here; this is just tidying!+        -- Trying to do so led to #17294+        --+        -- Set inline-prag info so that we preserve it across+        -- separate compilation boundaries+        old_info = idInfo id+        new_info = vanillaIdInfo+                    `setOccInfo`        occInfo old_info+                    `setArityInfo`      arityInfo old_info+                    `setStrictnessInfo` zapUsageEnvSig (strictnessInfo old_info)+                    `setDemandInfo`     demandInfo old_info+                    `setInlinePragInfo` inlinePragInfo old_info+                    `setUnfoldingInfo`  new_unf++        old_unf = unfoldingInfo old_info+        new_unf | isStableUnfolding old_unf = tidyUnfolding rec_tidy_env old_unf old_unf+                | otherwise                 = zapUnfolding old_unf+                                              -- See Note [Preserve evaluatedness]++    in+    ((tidy_env', var_env'), id') }++------------ Unfolding  --------------+tidyUnfolding :: TidyEnv -> Unfolding -> Unfolding -> Unfolding+tidyUnfolding tidy_env df@(DFunUnfolding { df_bndrs = bndrs, df_args = args }) _+  = df { df_bndrs = bndrs', df_args = map (tidyExpr tidy_env') args }+  where+    (tidy_env', bndrs') = tidyBndrs tidy_env bndrs++tidyUnfolding tidy_env+              unf@(CoreUnfolding { uf_tmpl = unf_rhs, uf_src = src })+              unf_from_rhs+  | isStableSource src+  = 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 (GHC.CoreToIface doesn't look at them)++  | otherwise+  = unf_from_rhs+  where seqIt unf = seqUnfolding unf `seq` unf+tidyUnfolding _ unf _ = unf     -- NoUnfolding or OtherCon++{-+Note [Tidy IdInfo]+~~~~~~~~~~~~~~~~~~+All nested Ids now have the same IdInfo, namely vanillaIdInfo, which+should save some space; except that we preserve occurrence info for+two reasons:++  (a) To make printing tidy core nicer++  (b) Because we tidy RULES and InlineRules, which may then propagate+      via --make into the compilation of the next module, and we want+      the benefit of that occurrence analysis when we use the rule or+      or inline the function.  In particular, it's vital not to lose+      loop-breaker info, else we get an infinite inlining loop++Note that tidyLetBndr puts more IdInfo back.++Note [Preserve evaluatedness]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+  data T = MkT !Bool+  ....(case v of MkT y ->+       let z# = case y of+                  True -> 1#+                  False -> 2#+       in ...)++The z# binding is ok because the RHS is ok-for-speculation,+but Lint will complain unless it can *see* that.  So we+preserve the evaluated-ness on 'y' in tidyBndr.++(Another alternative would be to tidy unboxed lets into cases,+but that seems more indirect and surprising.)++Note [Preserve OneShotInfo]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+We keep the OneShotInfo because we want it to propagate into the interface.+Not all OneShotInfo is determined by a compiler analysis; some is added by a+call of GHC.Exts.oneShot, which is then discarded before the end of the+optimisation pipeline, leaving only the OneShotInfo on the lambda. Hence we+must preserve this info in inlinings. See Note [The oneShot function] in MkId.++This applies to lambda binders only, hence it is stored in IfaceLamBndr.+-}++(=:) :: a -> (a -> b) -> b+m =: k = m `seq` k m

+ compiler/GHC/Core/Ppr.hs view

@@ -0,0 +1,657 @@+{-+(c) The University of Glasgow 2006+(c) The AQUA Project, Glasgow University, 1996-1998+++Printing of Core syntax+-}++{-# LANGUAGE MultiWayIf #-}+{-# LANGUAGE LambdaCase #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}++module GHC.Core.Ppr (+        pprCoreExpr, pprParendExpr,+        pprCoreBinding, pprCoreBindings, pprCoreAlt,+        pprCoreBindingWithSize, pprCoreBindingsWithSize,+        pprRules, pprOptCo+    ) where++import GhcPrelude++import GHC.Core+import GHC.Core.Stats (exprStats)+import Literal( pprLiteral )+import Name( pprInfixName, pprPrefixName )+import Var+import Id+import IdInfo+import Demand+import Cpr+import DataCon+import TyCon+import TyCoPpr+import Coercion+import BasicTypes+import Maybes+import Util+import Outputable+import FastString+import SrcLoc      ( pprUserRealSpan )++{-+************************************************************************+*                                                                      *+\subsection{Public interfaces for Core printing (excluding instances)}+*                                                                      *+************************************************************************++@pprParendCoreExpr@ puts parens around non-atomic Core expressions.+-}++pprCoreBindings :: OutputableBndr b => [Bind b] -> SDoc+pprCoreBinding  :: OutputableBndr b => Bind b  -> SDoc+pprCoreExpr     :: OutputableBndr b => Expr b  -> SDoc+pprParendExpr   :: OutputableBndr b => Expr b  -> SDoc++pprCoreBindings = pprTopBinds noAnn+pprCoreBinding  = pprTopBind noAnn++pprCoreBindingsWithSize :: [CoreBind] -> SDoc+pprCoreBindingWithSize  :: CoreBind  -> SDoc++pprCoreBindingsWithSize = pprTopBinds sizeAnn+pprCoreBindingWithSize = pprTopBind sizeAnn++instance OutputableBndr b => Outputable (Bind b) where+    ppr bind = ppr_bind noAnn bind++instance OutputableBndr b => Outputable (Expr b) where+    ppr expr = pprCoreExpr expr++{-+************************************************************************+*                                                                      *+\subsection{The guts}+*                                                                      *+************************************************************************+-}++-- | A function to produce an annotation for a given right-hand-side+type Annotation b = Expr b -> SDoc++-- | Annotate with the size of the right-hand-side+sizeAnn :: CoreExpr -> SDoc+sizeAnn e = text "-- RHS size:" <+> ppr (exprStats e)++-- | No annotation+noAnn :: Expr b -> SDoc+noAnn _ = empty++pprTopBinds :: OutputableBndr a+            => Annotation a -- ^ generate an annotation to place before the+                            -- binding+            -> [Bind a]     -- ^ bindings to show+            -> SDoc         -- ^ the pretty result+pprTopBinds ann binds = vcat (map (pprTopBind ann) binds)++pprTopBind :: OutputableBndr a => Annotation a -> Bind a -> SDoc+pprTopBind ann (NonRec binder expr)+ = ppr_binding ann (binder,expr) $$ blankLine++pprTopBind _ (Rec [])+  = text "Rec { }"+pprTopBind ann (Rec (b:bs))+  = vcat [text "Rec {",+          ppr_binding ann b,+          vcat [blankLine $$ ppr_binding ann b | b <- bs],+          text "end Rec }",+          blankLine]++ppr_bind :: OutputableBndr b => Annotation b -> Bind b -> SDoc++ppr_bind ann (NonRec val_bdr expr) = ppr_binding ann (val_bdr, expr)+ppr_bind ann (Rec binds)           = vcat (map pp binds)+                                    where+                                      pp bind = ppr_binding ann bind <> semi++ppr_binding :: OutputableBndr b => Annotation b -> (b, Expr b) -> SDoc+ppr_binding ann (val_bdr, expr)+  = vcat [ ann expr+         , ppUnlessOption sdocSuppressTypeSignatures+             (pprBndr LetBind val_bdr)+         , pp_bind+         ]+  where+    pp_bind = case bndrIsJoin_maybe val_bdr of+                Nothing -> pp_normal_bind+                Just ar -> pp_join_bind ar++    pp_normal_bind = hang (ppr val_bdr) 2 (equals <+> pprCoreExpr expr)++      -- For a join point of join arity n, we want to print j = \x1 ... xn -> e+      -- as "j x1 ... xn = e" to differentiate when a join point returns a+      -- lambda (the first rendering looks like a nullary join point returning+      -- an n-argument function).+    pp_join_bind join_arity+      | bndrs `lengthAtLeast` join_arity+      = hang (ppr val_bdr <+> sep (map (pprBndr LambdaBind) lhs_bndrs))+           2 (equals <+> pprCoreExpr rhs)+      | otherwise -- Yikes!  A join-binding with too few lambda+                  -- Lint will complain, but we don't want to crash+                  -- the pretty-printer else we can't see what's wrong+                  -- So refer to printing  j = e+      = pp_normal_bind+      where+        (bndrs, body) = collectBinders expr+        lhs_bndrs = take join_arity bndrs+        rhs       = mkLams (drop join_arity bndrs) body++pprParendExpr expr = ppr_expr parens expr+pprCoreExpr   expr = ppr_expr noParens expr++noParens :: SDoc -> SDoc+noParens pp = pp++pprOptCo :: Coercion -> SDoc+-- Print a coercion optionally; i.e. honouring -dsuppress-coercions+pprOptCo co = sdocOption sdocSuppressCoercions $ \case+              True  -> angleBrackets (text "Co:" <> int (coercionSize co))+              False -> parens $ sep [ppr co, dcolon <+> ppr (coercionType co)]++ppr_expr :: OutputableBndr b => (SDoc -> SDoc) -> Expr b -> SDoc+        -- The function adds parens in context that need+        -- an atomic value (e.g. function args)++ppr_expr add_par (Var name)+ | isJoinId name               = add_par ((text "jump") <+> ppr name)+ | otherwise                   = ppr name+ppr_expr add_par (Type ty)     = add_par (text "TYPE:" <+> ppr ty)       -- Weird+ppr_expr add_par (Coercion co) = add_par (text "CO:" <+> ppr co)+ppr_expr add_par (Lit lit)     = pprLiteral add_par lit++ppr_expr add_par (Cast expr co)+  = add_par $ sep [pprParendExpr expr, text "`cast`" <+> pprOptCo co]++ppr_expr add_par expr@(Lam _ _)+  = let+        (bndrs, body) = collectBinders expr+    in+    add_par $+    hang (text "\\" <+> sep (map (pprBndr LambdaBind) bndrs) <+> arrow)+         2 (pprCoreExpr body)++ppr_expr add_par expr@(App {})+  = sdocOption sdocSuppressTypeApplications $ \supp_ty_app ->+    case collectArgs expr of { (fun, args) ->+    let+        pp_args     = sep (map pprArg args)+        val_args    = dropWhile isTypeArg args   -- Drop the type arguments for tuples+        pp_tup_args = pprWithCommas pprCoreExpr val_args+        args'+          | supp_ty_app = val_args+          | otherwise   = args+        parens+          | null args' = id+          | otherwise  = add_par+    in+    case fun of+        Var f -> case isDataConWorkId_maybe f of+                        -- Notice that we print the *worker*+                        -- for tuples in paren'd format.+                   Just dc | saturated+                           , Just sort <- tyConTuple_maybe tc+                           -> tupleParens sort pp_tup_args+                           where+                             tc        = dataConTyCon dc+                             saturated = val_args `lengthIs` idArity f++                   _ -> parens (hang fun_doc 2 pp_args)+                   where+                     fun_doc | isJoinId f = text "jump" <+> ppr f+                             | otherwise  = ppr f++        _ -> parens (hang (pprParendExpr fun) 2 pp_args)+    }++ppr_expr add_par (Case expr var ty [(con,args,rhs)])+  = sdocOption sdocPrintCaseAsLet $ \case+      True -> add_par $  -- See Note [Print case as let]+               sep [ sep [ text "let! {"+                           <+> ppr_case_pat con args+                           <+> text "~"+                           <+> ppr_bndr var+                         , text "<-" <+> ppr_expr id expr+                           <+> text "} in" ]+                   , pprCoreExpr rhs+                   ]+      False -> add_par $+                sep [sep [sep [ text "case" <+> pprCoreExpr expr+                              , whenPprDebug (text "return" <+> ppr ty)+                              , text "of" <+> ppr_bndr var+                              ]+                         , char '{' <+> ppr_case_pat con args <+> arrow+                         ]+                     , pprCoreExpr rhs+                     , char '}'+                     ]+  where+    ppr_bndr = pprBndr CaseBind++ppr_expr add_par (Case expr var ty alts)+  = add_par $+    sep [sep [text "case"+                <+> pprCoreExpr expr+                <+> whenPprDebug (text "return" <+> ppr ty),+              text "of" <+> ppr_bndr var <+> char '{'],+         nest 2 (vcat (punctuate semi (map pprCoreAlt alts))),+         char '}'+    ]+  where+    ppr_bndr = pprBndr CaseBind+++-- special cases: let ... in let ...+-- ("disgusting" SLPJ)++{-+ppr_expr add_par (Let bind@(NonRec val_bdr rhs@(Let _ _)) body)+  = add_par $+    vcat [+      hsep [text "let {", (pprBndr LetBind val_bdr $$ ppr val_bndr), equals],+      nest 2 (pprCoreExpr rhs),+      text "} in",+      pprCoreExpr body ]++ppr_expr add_par (Let bind@(NonRec val_bdr rhs) expr@(Let _ _))+  = add_par+    (hang (text "let {")+          2 (hsep [ppr_binding (val_bdr,rhs),+                   text "} in"])+     $$+     pprCoreExpr expr)+-}+++-- General case (recursive case, too)+ppr_expr add_par (Let bind expr)+  = add_par $+    sep [hang (keyword bind <+> char '{') 2 (ppr_bind noAnn bind <+> text "} in"),+         pprCoreExpr expr]+  where+    keyword (NonRec b _)+     | isJust (bndrIsJoin_maybe b) = text "join"+     | otherwise                   = text "let"+    keyword (Rec pairs)+     | ((b,_):_) <- pairs+     , isJust (bndrIsJoin_maybe b) = text "joinrec"+     | otherwise                   = text "letrec"++ppr_expr add_par (Tick tickish expr)+  = sdocOption sdocSuppressTicks $ \case+      True  -> ppr_expr add_par expr+      False -> add_par (sep [ppr tickish, pprCoreExpr expr])++pprCoreAlt :: OutputableBndr a => (AltCon, [a] , Expr a) -> SDoc+pprCoreAlt (con, args, rhs)+  = hang (ppr_case_pat con args <+> arrow) 2 (pprCoreExpr rhs)++ppr_case_pat :: OutputableBndr a => AltCon -> [a] -> SDoc+ppr_case_pat (DataAlt dc) args+  | Just sort <- tyConTuple_maybe tc+  = tupleParens sort (pprWithCommas ppr_bndr args)+  where+    ppr_bndr = pprBndr CasePatBind+    tc = dataConTyCon dc++ppr_case_pat con args+  = ppr con <+> (fsep (map ppr_bndr args))+  where+    ppr_bndr = pprBndr CasePatBind+++-- | Pretty print the argument in a function application.+pprArg :: OutputableBndr a => Expr a -> SDoc+pprArg (Type ty)+ = ppUnlessOption sdocSuppressTypeApplications+      (text "@" <> pprParendType ty)+pprArg (Coercion co) = text "@~" <> pprOptCo co+pprArg expr          = pprParendExpr expr++{-+Note [Print case as let]+~~~~~~~~~~~~~~~~~~~~~~~~+Single-branch case expressions are very common:+   case x of y { I# x' ->+   case p of q { I# p' -> ... } }+These are, in effect, just strict let's, with pattern matching.+With -dppr-case-as-let we print them as such:+   let! { I# x' ~ y <- x } in+   let! { I# p' ~ q <- p } in ...+++Other printing bits-and-bobs used with the general @pprCoreBinding@+and @pprCoreExpr@ functions.+++Note [Binding-site specific printing]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++pprCoreBinder and pprTypedLamBinder receive a BindingSite argument to adjust+the information printed.++Let-bound binders are printed with their full type and idInfo.++Case-bound variables (both the case binder and pattern variables) are printed+without a type and without their unfolding.++Furthermore, a dead case-binder is completely ignored, while otherwise, dead+binders are printed as "_".+-}++-- These instances are sadly orphans++instance OutputableBndr Var where+  pprBndr = pprCoreBinder+  pprInfixOcc  = pprInfixName  . varName+  pprPrefixOcc = pprPrefixName . varName+  bndrIsJoin_maybe = isJoinId_maybe++instance Outputable b => OutputableBndr (TaggedBndr b) where+  pprBndr _    b = ppr b   -- Simple+  pprInfixOcc  b = ppr b+  pprPrefixOcc b = ppr b+  bndrIsJoin_maybe (TB b _) = isJoinId_maybe b++pprCoreBinder :: BindingSite -> Var -> SDoc+pprCoreBinder LetBind binder+  | isTyVar binder = pprKindedTyVarBndr binder+  | otherwise      = pprTypedLetBinder binder $$+                     ppIdInfo binder (idInfo binder)++-- Lambda bound type variables are preceded by "@"+pprCoreBinder bind_site bndr+  = getPprStyle $ \ sty ->+    pprTypedLamBinder bind_site (debugStyle sty) bndr++pprUntypedBinder :: Var -> SDoc+pprUntypedBinder binder+  | isTyVar binder = text "@" <> ppr binder    -- NB: don't print kind+  | otherwise      = pprIdBndr binder++pprTypedLamBinder :: BindingSite -> Bool -> Var -> SDoc+-- For lambda and case binders, show the unfolding info (usually none)+pprTypedLamBinder bind_site debug_on var+  = sdocOption sdocSuppressTypeSignatures $ \suppress_sigs ->+    case () of+    _+      | not debug_on            -- Show case-bound wild binders only if debug is on+      , CaseBind <- bind_site+      , isDeadBinder var        -> empty++      | not debug_on            -- Even dead binders can be one-shot+      , isDeadBinder var        -> char '_' <+> ppWhen (isId var)+                                                (pprIdBndrInfo (idInfo var))++      | not debug_on            -- No parens, no kind info+      , CaseBind <- bind_site   -> pprUntypedBinder var++      | not debug_on+      , CasePatBind <- bind_site    -> pprUntypedBinder var++      | suppress_sigs -> pprUntypedBinder var++      | isTyVar var  -> parens (pprKindedTyVarBndr var)++      | otherwise    -> parens (hang (pprIdBndr var)+                                   2 (vcat [ dcolon <+> pprType (idType var)+                                           , pp_unf]))+  where+    unf_info = unfoldingInfo (idInfo var)+    pp_unf | hasSomeUnfolding unf_info = text "Unf=" <> ppr unf_info+           | otherwise                 = empty++pprTypedLetBinder :: Var -> SDoc+-- Print binder with a type or kind signature (not paren'd)+pprTypedLetBinder binder+  = sdocOption sdocSuppressTypeSignatures $ \suppress_sigs ->+    case () of+    _+      | isTyVar binder -> pprKindedTyVarBndr binder+      | suppress_sigs  -> pprIdBndr binder+      | otherwise      -> hang (pprIdBndr binder) 2 (dcolon <+> pprType (idType binder))++pprKindedTyVarBndr :: TyVar -> SDoc+-- Print a type variable binder with its kind (but not if *)+pprKindedTyVarBndr tyvar+  = text "@" <> pprTyVar tyvar++-- pprIdBndr does *not* print the type+-- When printing any Id binder in debug mode, we print its inline pragma and one-shot-ness+pprIdBndr :: Id -> SDoc+pprIdBndr id = ppr id <+> pprIdBndrInfo (idInfo id)++pprIdBndrInfo :: IdInfo -> SDoc+pprIdBndrInfo info+  = ppUnlessOption sdocSuppressIdInfo+      (info `seq` doc) -- The seq is useful for poking on black holes+  where+    prag_info = inlinePragInfo info+    occ_info  = occInfo info+    dmd_info  = demandInfo info+    lbv_info  = oneShotInfo info++    has_prag  = not (isDefaultInlinePragma prag_info)+    has_occ   = not (isManyOccs occ_info)+    has_dmd   = not $ isTopDmd dmd_info+    has_lbv   = not (hasNoOneShotInfo lbv_info)++    doc = showAttributes+          [ (has_prag, text "InlPrag=" <> pprInlineDebug prag_info)+          , (has_occ,  text "Occ=" <> ppr occ_info)+          , (has_dmd,  text "Dmd=" <> ppr dmd_info)+          , (has_lbv , text "OS=" <> ppr lbv_info)+          ]++instance Outputable IdInfo where+  ppr info = showAttributes+    [ (has_prag,         text "InlPrag=" <> pprInlineDebug prag_info)+    , (has_occ,          text "Occ=" <> ppr occ_info)+    , (has_dmd,          text "Dmd=" <> ppr dmd_info)+    , (has_lbv ,         text "OS=" <> ppr lbv_info)+    , (has_arity,        text "Arity=" <> int arity)+    , (has_called_arity, text "CallArity=" <> int called_arity)+    , (has_caf_info,     text "Caf=" <> ppr caf_info)+    , (has_str_info,     text "Str=" <> pprStrictness str_info)+    , (has_unf,          text "Unf=" <> ppr unf_info)+    , (has_rules,        text "RULES:" <+> vcat (map pprRule rules))+    ]+    where+      prag_info = inlinePragInfo info+      has_prag  = not (isDefaultInlinePragma prag_info)++      occ_info  = occInfo info+      has_occ   = not (isManyOccs occ_info)++      dmd_info  = demandInfo info+      has_dmd   = not $ isTopDmd dmd_info++      lbv_info  = oneShotInfo info+      has_lbv   = not (hasNoOneShotInfo lbv_info)++      arity = arityInfo info+      has_arity = arity /= 0++      called_arity = callArityInfo info+      has_called_arity = called_arity /= 0++      caf_info = cafInfo info+      has_caf_info = not (mayHaveCafRefs caf_info)++      str_info = strictnessInfo info+      has_str_info = not (isTopSig str_info)++      unf_info = unfoldingInfo info+      has_unf = hasSomeUnfolding unf_info++      rules = ruleInfoRules (ruleInfo info)+      has_rules = not (null rules)++{-+-----------------------------------------------------+--      IdDetails and IdInfo+-----------------------------------------------------+-}++ppIdInfo :: Id -> IdInfo -> SDoc+ppIdInfo id info+  = ppUnlessOption sdocSuppressIdInfo $+    showAttributes+    [ (True, pp_scope <> ppr (idDetails id))+    , (has_arity,        text "Arity=" <> int arity)+    , (has_called_arity, text "CallArity=" <> int called_arity)+    , (has_caf_info,     text "Caf=" <> ppr caf_info)+    , (has_str_info,     text "Str=" <> pprStrictness str_info)+    , (has_cpr_info,     text "Cpr=" <> ppr cpr_info)+    , (has_unf,          text "Unf=" <> ppr unf_info)+    , (not (null rules), text "RULES:" <+> vcat (map pprRule rules))+    ]   -- Inline pragma, occ, demand, one-shot info+        -- printed out with all binders (when debug is on);+        -- see GHC.Core.Ppr.pprIdBndr+  where+    pp_scope | isGlobalId id   = text "GblId"+             | isExportedId id = text "LclIdX"+             | otherwise       = text "LclId"++    arity = arityInfo info+    has_arity = arity /= 0++    called_arity = callArityInfo info+    has_called_arity = called_arity /= 0++    caf_info = cafInfo info+    has_caf_info = not (mayHaveCafRefs caf_info)++    str_info = strictnessInfo info+    has_str_info = not (isTopSig str_info)++    cpr_info = cprInfo info+    has_cpr_info = cpr_info /= topCprSig++    unf_info = unfoldingInfo info+    has_unf = hasSomeUnfolding unf_info++    rules = ruleInfoRules (ruleInfo info)++showAttributes :: [(Bool,SDoc)] -> SDoc+showAttributes stuff+  | null docs = empty+  | otherwise = brackets (sep (punctuate comma docs))+  where+    docs = [d | (True,d) <- stuff]++{-+-----------------------------------------------------+--      Unfolding and UnfoldingGuidance+-----------------------------------------------------+-}++instance Outputable UnfoldingGuidance where+    ppr UnfNever  = text "NEVER"+    ppr (UnfWhen { ug_arity = arity, ug_unsat_ok = unsat_ok, ug_boring_ok = boring_ok })+      = text "ALWAYS_IF" <>+        parens (text "arity="     <> int arity    <> comma <>+                text "unsat_ok="  <> ppr unsat_ok <> comma <>+                text "boring_ok=" <> ppr boring_ok)+    ppr (UnfIfGoodArgs { ug_args = cs, ug_size = size, ug_res = discount })+      = hsep [ text "IF_ARGS",+               brackets (hsep (map int cs)),+               int size,+               int discount ]++instance Outputable UnfoldingSource where+  ppr InlineCompulsory  = text "Compulsory"+  ppr InlineStable      = text "InlineStable"+  ppr InlineRhs         = text "<vanilla>"++instance Outputable Unfolding where+  ppr NoUnfolding                = text "No unfolding"+  ppr BootUnfolding              = text "No unfolding (from boot)"+  ppr (OtherCon cs)              = text "OtherCon" <+> ppr cs+  ppr (DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = args })+       = hang (text "DFun:" <+> ptext (sLit "\\")+                <+> sep (map (pprBndr LambdaBind) bndrs) <+> arrow)+            2 (ppr con <+> sep (map ppr args))+  ppr (CoreUnfolding { uf_src = src+                     , uf_tmpl=rhs, uf_is_top=top, uf_is_value=hnf+                     , uf_is_conlike=conlike, uf_is_work_free=wf+                     , uf_expandable=exp, uf_guidance=g })+        = text "Unf" <> braces (pp_info $$ pp_rhs)+    where+      pp_info = fsep $ punctuate comma+                [ text "Src="        <> ppr src+                , text "TopLvl="     <> ppr top+                , text "Value="      <> ppr hnf+                , text "ConLike="    <> ppr conlike+                , text "WorkFree="   <> ppr wf+                , text "Expandable=" <> ppr exp+                , text "Guidance="   <> ppr g ]+      pp_tmpl = ppUnlessOption sdocSuppressUnfoldings+                  (text "Tmpl=" <+> ppr rhs)+      pp_rhs | isStableSource src = pp_tmpl+             | otherwise          = empty+            -- Don't print the RHS or we get a quadratic+            -- blowup in the size of the printout!++{-+-----------------------------------------------------+--      Rules+-----------------------------------------------------+-}++instance Outputable CoreRule where+   ppr = pprRule++pprRules :: [CoreRule] -> SDoc+pprRules rules = vcat (map pprRule rules)++pprRule :: CoreRule -> SDoc+pprRule (BuiltinRule { ru_fn = fn, ru_name = name})+  = text "Built in rule for" <+> ppr fn <> colon <+> doubleQuotes (ftext name)++pprRule (Rule { ru_name = name, ru_act = act, ru_fn = fn,+                ru_bndrs = tpl_vars, ru_args = tpl_args,+                ru_rhs = rhs })+  = hang (doubleQuotes (ftext name) <+> ppr act)+       4 (sep [text "forall" <+>+                  sep (map (pprCoreBinder LambdaBind) tpl_vars) <> dot,+               nest 2 (ppr fn <+> sep (map pprArg tpl_args)),+               nest 2 (text "=" <+> pprCoreExpr rhs)+            ])++{-+-----------------------------------------------------+--      Tickish+-----------------------------------------------------+-}++instance Outputable id => Outputable (Tickish id) where+  ppr (HpcTick modl ix) =+      hcat [text "hpc<",+            ppr modl, comma,+            ppr ix,+            text ">"]+  ppr (Breakpoint ix vars) =+      hcat [text "break<",+            ppr ix,+            text ">",+            parens (hcat (punctuate comma (map ppr vars)))]+  ppr (ProfNote { profNoteCC = cc,+                  profNoteCount = tick,+                  profNoteScope = scope }) =+      case (tick,scope) of+         (True,True)  -> hcat [text "scctick<", ppr cc, char '>']+         (True,False) -> hcat [text "tick<",    ppr cc, char '>']+         _            -> hcat [text "scc<",     ppr cc, char '>']+  ppr (SourceNote span _) =+      hcat [ text "src<", pprUserRealSpan True span, char '>']

+ compiler/GHC/Core/Rules.hs view

@@ -0,0 +1,1254 @@+{-+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++\section[CoreRules]{Transformation rules}+-}++{-# LANGUAGE CPP #-}++-- | Functions for collecting together and applying rewrite rules to a module.+-- The 'CoreRule' datatype itself is declared elsewhere.+module GHC.Core.Rules (+        -- ** Constructing+        emptyRuleBase, mkRuleBase, extendRuleBaseList,+        unionRuleBase, pprRuleBase,++        -- ** Checking rule applications+        ruleCheckProgram,++        -- ** Manipulating 'RuleInfo' rules+        mkRuleInfo, extendRuleInfo, addRuleInfo,+        addIdSpecialisations,++        -- * Misc. CoreRule helpers+        rulesOfBinds, getRules, pprRulesForUser,++        lookupRule, mkRule, roughTopNames+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Core         -- All of it+import Module           ( Module, ModuleSet, elemModuleSet )+import GHC.Core.Subst+import GHC.Core.SimpleOpt ( exprIsLambda_maybe )+import GHC.Core.FVs     ( exprFreeVars, exprsFreeVars, bindFreeVars+                        , rulesFreeVarsDSet, exprsOrphNames, exprFreeVarsList )+import GHC.Core.Utils   ( exprType, eqExpr, mkTick, mkTicks+                        , stripTicksTopT, stripTicksTopE+                        , isJoinBind )+import GHC.Core.Ppr     ( pprRules )+import Type             ( Type, TCvSubst, extendTvSubst, extendCvSubst+                        , mkEmptyTCvSubst, substTy )+import TcType           ( tcSplitTyConApp_maybe )+import TysWiredIn       ( anyTypeOfKind )+import Coercion+import GHC.Core.Op.Tidy ( tidyRules )+import Id+import IdInfo           ( RuleInfo( RuleInfo ) )+import Var+import VarEnv+import VarSet+import Name             ( Name, NamedThing(..), nameIsLocalOrFrom )+import NameSet+import NameEnv+import UniqFM+import Unify            ( ruleMatchTyKiX )+import BasicTypes+import GHC.Driver.Session         ( DynFlags )+import Outputable+import FastString+import Maybes+import Bag+import Util+import Data.List+import Data.Ord+import Control.Monad    ( guard )++{-+Note [Overall plumbing for rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+* After the desugarer:+   - The ModGuts initially contains mg_rules :: [CoreRule] of+     locally-declared rules for imported Ids.+   - Locally-declared rules for locally-declared Ids are attached to+     the IdInfo for that Id.  See Note [Attach rules to local ids] in+     GHC.HsToCore.Binds++* GHC.Iface.Tidy strips off all the rules from local Ids and adds them to+  mg_rules, so that the ModGuts has *all* the locally-declared rules.++* The HomePackageTable contains a ModDetails for each home package+  module.  Each contains md_rules :: [CoreRule] of rules declared in+  that module.  The HomePackageTable grows as ghc --make does its+  up-sweep.  In batch mode (ghc -c), the HPT is empty; all imported modules+  are treated by the "external" route, discussed next, regardless of+  which package they come from.++* The ExternalPackageState has a single eps_rule_base :: RuleBase for+  Ids in other packages.  This RuleBase simply grow monotonically, as+  ghc --make compiles one module after another.++  During simplification, interface files may get demand-loaded,+  as the simplifier explores the unfoldings for Ids it has in+  its hand.  (Via an unsafePerformIO; the EPS is really a cache.)+  That in turn may make the EPS rule-base grow.  In contrast, the+  HPT never grows in this way.++* The result of all this is that during Core-to-Core optimisation+  there are four sources of rules:++    (a) Rules in the IdInfo of the Id they are a rule for.  These are+        easy: fast to look up, and if you apply a substitution then+        it'll be applied to the IdInfo as a matter of course.++    (b) Rules declared in this module for imported Ids, kept in the+        ModGuts. If you do a substitution, you'd better apply the+        substitution to these.  There are seldom many of these.++    (c) Rules declared in the HomePackageTable.  These never change.++    (d) Rules in the ExternalPackageTable. These can grow in response+        to lazy demand-loading of interfaces.++* At the moment (c) is carried in a reader-monad way by the CoreMonad.+  The HomePackageTable doesn't have a single RuleBase because technically+  we should only be able to "see" rules "below" this module; so we+  generate a RuleBase for (c) by combing rules from all the modules+  "below" us.  That's why we can't just select the home-package RuleBase+  from HscEnv.++  [NB: we are inconsistent here.  We should do the same for external+  packages, but we don't.  Same for type-class instances.]++* So in the outer simplifier loop, we combine (b-d) into a single+  RuleBase, reading+     (b) from the ModGuts,+     (c) from the CoreMonad, and+     (d) from its mutable variable+  [Of course this means that we won't see new EPS rules that come in+  during a single simplifier iteration, but that probably does not+  matter.]+++************************************************************************+*                                                                      *+\subsection[specialisation-IdInfo]{Specialisation info about an @Id@}+*                                                                      *+************************************************************************++A @CoreRule@ holds details of one rule for an @Id@, which+includes its specialisations.++For example, if a rule for @f@ contains the mapping:+\begin{verbatim}+        forall a b d. [Type (List a), Type b, Var d]  ===>  f' a b+\end{verbatim}+then when we find an application of f to matching types, we simply replace+it by the matching RHS:+\begin{verbatim}+        f (List Int) Bool dict ===>  f' Int Bool+\end{verbatim}+All the stuff about how many dictionaries to discard, and what types+to apply the specialised function to, are handled by the fact that the+Rule contains a template for the result of the specialisation.++There is one more exciting case, which is dealt with in exactly the same+way.  If the specialised value is unboxed then it is lifted at its+definition site and unlifted at its uses.  For example:++        pi :: forall a. Num a => a++might have a specialisation++        [Int#] ===>  (case pi' of Lift pi# -> pi#)++where pi' :: Lift Int# is the specialised version of pi.+-}++mkRule :: Module -> Bool -> Bool -> RuleName -> Activation+       -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule+-- ^ Used to make 'CoreRule' for an 'Id' defined in the module being+-- compiled. See also 'GHC.Core.CoreRule'+mkRule this_mod is_auto is_local name act fn bndrs args rhs+  = Rule { ru_name = name, ru_fn = fn, ru_act = act,+           ru_bndrs = bndrs, ru_args = args,+           ru_rhs = rhs,+           ru_rough = roughTopNames args,+           ru_origin = this_mod,+           ru_orphan = orph,+           ru_auto = is_auto, ru_local = is_local }+  where+        -- Compute orphanhood.  See Note [Orphans] in InstEnv+        -- A rule is an orphan only if none of the variables+        -- mentioned on its left-hand side are locally defined+    lhs_names = extendNameSet (exprsOrphNames args) fn++        -- Since rules get eventually attached to one of the free names+        -- from the definition when compiling the ABI hash, we should make+        -- it deterministic. This chooses the one with minimal OccName+        -- as opposed to uniq value.+    local_lhs_names = filterNameSet (nameIsLocalOrFrom this_mod) lhs_names+    orph = chooseOrphanAnchor local_lhs_names++--------------+roughTopNames :: [CoreExpr] -> [Maybe Name]+-- ^ Find the \"top\" free names of several expressions.+-- Such names are either:+--+-- 1. The function finally being applied to in an application chain+--    (if that name is a GlobalId: see "Var#globalvslocal"), or+--+-- 2. The 'TyCon' if the expression is a 'Type'+--+-- This is used for the fast-match-check for rules;+--      if the top names don't match, the rest can't+roughTopNames args = map roughTopName args++roughTopName :: CoreExpr -> Maybe Name+roughTopName (Type ty) = case tcSplitTyConApp_maybe ty of+                               Just (tc,_) -> Just (getName tc)+                               Nothing     -> Nothing+roughTopName (Coercion _) = Nothing+roughTopName (App f _) = roughTopName f+roughTopName (Var f)   | isGlobalId f   -- Note [Care with roughTopName]+                       , isDataConWorkId f || idArity f > 0+                       = Just (idName f)+roughTopName (Tick t e) | tickishFloatable t+                        = roughTopName e+roughTopName _ = Nothing++ruleCantMatch :: [Maybe Name] -> [Maybe Name] -> Bool+-- ^ @ruleCantMatch tpl actual@ returns True only if @actual@+-- definitely can't match @tpl@ by instantiating @tpl@.+-- It's only a one-way match; unlike instance matching we+-- don't consider unification.+--+-- Notice that [_$_]+--      @ruleCantMatch [Nothing] [Just n2] = False@+--      Reason: a template variable can be instantiated by a constant+-- Also:+--      @ruleCantMatch [Just n1] [Nothing] = False@+--      Reason: a local variable @v@ in the actuals might [_$_]++ruleCantMatch (Just n1 : ts) (Just n2 : as) = n1 /= n2 || ruleCantMatch ts as+ruleCantMatch (_       : ts) (_       : as) = ruleCantMatch ts as+ruleCantMatch _              _              = False++{-+Note [Care with roughTopName]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this+    module M where { x = a:b }+    module N where { ...f x...+                     RULE f (p:q) = ... }+You'd expect the rule to match, because the matcher can+look through the unfolding of 'x'.  So we must avoid roughTopName+returning 'M.x' for the call (f x), or else it'll say "can't match"+and we won't even try!!++However, suppose we have+         RULE g (M.h x) = ...+         foo = ...(g (M.k v))....+where k is a *function* exported by M.  We never really match+functions (lambdas) except by name, so in this case it seems like+a good idea to treat 'M.k' as a roughTopName of the call.+-}++pprRulesForUser :: DynFlags -> [CoreRule] -> SDoc+-- (a) tidy the rules+-- (b) sort them into order based on the rule name+-- (c) suppress uniques (unless -dppr-debug is on)+-- This combination makes the output stable so we can use in testing+-- It's here rather than in GHC.Core.Ppr because it calls tidyRules+pprRulesForUser dflags rules+  = withPprStyle (defaultUserStyle dflags) $+    pprRules $+    sortBy (comparing ruleName) $+    tidyRules emptyTidyEnv rules++{-+************************************************************************+*                                                                      *+                RuleInfo: the rules in an IdInfo+*                                                                      *+************************************************************************+-}++-- | Make a 'RuleInfo' containing a number of 'CoreRule's, suitable+-- for putting into an 'IdInfo'+mkRuleInfo :: [CoreRule] -> RuleInfo+mkRuleInfo rules = RuleInfo rules (rulesFreeVarsDSet rules)++extendRuleInfo :: RuleInfo -> [CoreRule] -> RuleInfo+extendRuleInfo (RuleInfo rs1 fvs1) rs2+  = RuleInfo (rs2 ++ rs1) (rulesFreeVarsDSet rs2 `unionDVarSet` fvs1)++addRuleInfo :: RuleInfo -> RuleInfo -> RuleInfo+addRuleInfo (RuleInfo rs1 fvs1) (RuleInfo rs2 fvs2)+  = RuleInfo (rs1 ++ rs2) (fvs1 `unionDVarSet` fvs2)++addIdSpecialisations :: Id -> [CoreRule] -> Id+addIdSpecialisations id rules+  | null rules+  = id+  | otherwise+  = setIdSpecialisation id $+    extendRuleInfo (idSpecialisation id) rules++-- | Gather all the rules for locally bound identifiers from the supplied bindings+rulesOfBinds :: [CoreBind] -> [CoreRule]+rulesOfBinds binds = concatMap (concatMap idCoreRules . bindersOf) binds++getRules :: RuleEnv -> Id -> [CoreRule]+-- See Note [Where rules are found]+getRules (RuleEnv { re_base = rule_base, re_visible_orphs = orphs }) fn+  = idCoreRules fn ++ filter (ruleIsVisible orphs) imp_rules+  where+    imp_rules = lookupNameEnv rule_base (idName fn) `orElse` []++ruleIsVisible :: ModuleSet -> CoreRule -> Bool+ruleIsVisible _ BuiltinRule{} = True+ruleIsVisible vis_orphs Rule { ru_orphan = orph, ru_origin = origin }+    = notOrphan orph || origin `elemModuleSet` vis_orphs++{- Note [Where rules are found]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The rules for an Id come from two places:+  (a) the ones it is born with, stored inside the Id itself (idCoreRules fn),+  (b) rules added in other modules, stored in the global RuleBase (imp_rules)++It's tempting to think that+     - LocalIds have only (a)+     - non-LocalIds have only (b)++but that isn't quite right:++     - PrimOps and ClassOps are born with a bunch of rules inside the Id,+       even when they are imported++     - The rules in PrelRules.builtinRules should be active even+       in the module defining the Id (when it's a LocalId), but+       the rules are kept in the global RuleBase+++************************************************************************+*                                                                      *+                RuleBase+*                                                                      *+************************************************************************+-}++-- RuleBase itself is defined in GHC.Core, along with CoreRule++emptyRuleBase :: RuleBase+emptyRuleBase = emptyNameEnv++mkRuleBase :: [CoreRule] -> RuleBase+mkRuleBase rules = extendRuleBaseList emptyRuleBase rules++extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase+extendRuleBaseList rule_base new_guys+  = foldl' extendRuleBase rule_base new_guys++unionRuleBase :: RuleBase -> RuleBase -> RuleBase+unionRuleBase rb1 rb2 = plusNameEnv_C (++) rb1 rb2++extendRuleBase :: RuleBase -> CoreRule -> RuleBase+extendRuleBase rule_base rule+  = extendNameEnv_Acc (:) singleton rule_base (ruleIdName rule) rule++pprRuleBase :: RuleBase -> SDoc+pprRuleBase rules = pprUFM rules $ \rss ->+  vcat [ pprRules (tidyRules emptyTidyEnv rs)+       | rs <- rss ]++{-+************************************************************************+*                                                                      *+                        Matching+*                                                                      *+************************************************************************+-}++-- | The main rule matching function. Attempts to apply all (active)+-- supplied rules to this instance of an application in a given+-- context, returning the rule applied and the resulting expression if+-- successful.+lookupRule :: DynFlags -> InScopeEnv+           -> (Activation -> Bool)      -- When rule is active+           -> Id -> [CoreExpr]+           -> [CoreRule] -> Maybe (CoreRule, CoreExpr)++-- See Note [Extra args in rule matching]+-- See comments on matchRule+lookupRule dflags in_scope is_active fn args rules+  = -- pprTrace "matchRules" (ppr fn <+> ppr args $$ ppr rules ) $+    case go [] rules of+        []     -> Nothing+        (m:ms) -> Just (findBest (fn,args') m ms)+  where+    rough_args = map roughTopName args++    -- Strip ticks from arguments, see note [Tick annotations in RULE+    -- matching]. We only collect ticks if a rule actually matches -+    -- this matters for performance tests.+    args' = map (stripTicksTopE tickishFloatable) args+    ticks = concatMap (stripTicksTopT tickishFloatable) args++    go :: [(CoreRule,CoreExpr)] -> [CoreRule] -> [(CoreRule,CoreExpr)]+    go ms [] = ms+    go ms (r:rs)+      | Just e <- matchRule dflags in_scope is_active fn args' rough_args r+      = go ((r,mkTicks ticks e):ms) rs+      | otherwise+      = -- pprTrace "match failed" (ppr r $$ ppr args $$+        --   ppr [ (arg_id, unfoldingTemplate unf)+        --       | Var arg_id <- args+        --       , let unf = idUnfolding arg_id+        --       , isCheapUnfolding unf] )+        go ms rs++findBest :: (Id, [CoreExpr])+         -> (CoreRule,CoreExpr) -> [(CoreRule,CoreExpr)] -> (CoreRule,CoreExpr)+-- All these pairs matched the expression+-- Return the pair the most specific rule+-- The (fn,args) is just for overlap reporting++findBest _      (rule,ans)   [] = (rule,ans)+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+                      = ifPprDebug (ppr rule)+                                   (doubleQuotes (ftext (ruleName rule)))+                in pprTrace "Rules.findBest: rule overlap (Rule 1 wins)"+                         (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+  | otherwise = findBest target (rule1,ans1) prs+  where+    (fn,args) = target++isMoreSpecific :: CoreRule -> CoreRule -> Bool+-- This tests if one rule is more specific than another+-- We take the view that a BuiltinRule is less specific than+-- anything else, because we want user-define rules to "win"+-- In particular, class ops have a built-in rule, but we+-- any user-specific rules to win+--   eg (#4397)+--      truncate :: (RealFrac a, Integral b) => a -> b+--      {-# RULES "truncate/Double->Int" truncate = double2Int #-}+--      double2Int :: Double -> Int+--   We want the specific RULE to beat the built-in class-op rule+isMoreSpecific (BuiltinRule {}) _                = False+isMoreSpecific (Rule {})        (BuiltinRule {}) = True+isMoreSpecific (Rule { ru_bndrs = bndrs1, ru_args = args1 })+               (Rule { ru_bndrs = bndrs2, ru_args = args2+                     , ru_name = rule_name2, ru_rhs = rhs })+  = isJust (matchN (in_scope, id_unfolding_fun) rule_name2 bndrs2 args2 args1 rhs)+  where+   id_unfolding_fun _ = NoUnfolding     -- Don't expand in templates+   in_scope = mkInScopeSet (mkVarSet bndrs1)+        -- Actually we should probably include the free vars+        -- of rule1's args, but I can't be bothered++noBlackList :: Activation -> Bool+noBlackList _ = False           -- Nothing is black listed++{-+Note [Extra args in rule matching]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we find a matching rule, we return (Just (rule, rhs)),+but the rule firing has only consumed as many of the input args+as the ruleArity says.  It's up to the caller to keep track+of any left-over args.  E.g. if you call+        lookupRule ... f [e1, e2, e3]+and it returns Just (r, rhs), where r has ruleArity 2+then the real rewrite is+        f e1 e2 e3 ==> rhs e3++You might think it'd be cleaner for lookupRule to deal with the+leftover arguments, by applying 'rhs' to them, but the main call+in the Simplifier works better as it is.  Reason: the 'args' passed+to lookupRule are the result of a lazy substitution+-}++------------------------------------+matchRule :: DynFlags -> InScopeEnv -> (Activation -> Bool)+          -> Id -> [CoreExpr] -> [Maybe Name]+          -> CoreRule -> Maybe CoreExpr++-- If (matchRule rule args) returns Just (name,rhs)+-- then (f args) matches the rule, and the corresponding+-- rewritten RHS is rhs+--+-- The returned expression is occurrence-analysed+--+--      Example+--+-- The rule+--      forall f g x. map f (map g x) ==> map (f . g) x+-- is stored+--      CoreRule "map/map"+--               [f,g,x]                -- tpl_vars+--               [f,map g x]            -- tpl_args+--               map (f.g) x)           -- rhs+--+-- Then the call: matchRule the_rule [e1,map e2 e3]+--        = Just ("map/map", (\f,g,x -> rhs) e1 e2 e3)+--+-- Any 'surplus' arguments in the input are simply put on the end+-- of the output.++matchRule dflags rule_env _is_active fn args _rough_args+          (BuiltinRule { ru_try = match_fn })+-- Built-in rules can't be switched off, it seems+  = case match_fn dflags rule_env fn args of+        Nothing   -> Nothing+        Just expr -> Just expr++matchRule _ in_scope is_active _ args rough_args+          (Rule { ru_name = rule_name, ru_act = act, ru_rough = tpl_tops+                , ru_bndrs = tpl_vars, ru_args = tpl_args, ru_rhs = rhs })+  | not (is_active act)               = Nothing+  | ruleCantMatch tpl_tops rough_args = Nothing+  | otherwise = matchN in_scope rule_name tpl_vars tpl_args args rhs++---------------------------------------+matchN  :: InScopeEnv+        -> RuleName -> [Var] -> [CoreExpr]+        -> [CoreExpr] -> CoreExpr           -- ^ Target; can have more elements than the template+        -> Maybe CoreExpr+-- For a given match template and context, find bindings to wrap around+-- the entire result and what should be substituted for each template variable.+-- Fail if there are two few actual arguments from the target to match the template++matchN (in_scope, id_unf) rule_name tmpl_vars tmpl_es target_es rhs+  = do  { rule_subst <- go init_menv emptyRuleSubst tmpl_es target_es+        ; let (_, matched_es) = mapAccumL (lookup_tmpl rule_subst)+                                          (mkEmptyTCvSubst in_scope) $+                                tmpl_vars `zip` tmpl_vars1+              bind_wrapper = rs_binds rule_subst+                             -- Floated bindings; see Note [Matching lets]+       ; return (bind_wrapper $+                 mkLams tmpl_vars rhs `mkApps` matched_es) }+  where+    (init_rn_env, tmpl_vars1) = mapAccumL rnBndrL (mkRnEnv2 in_scope) tmpl_vars+                  -- See Note [Cloning the template binders]++    init_menv = RV { rv_tmpls = mkVarSet tmpl_vars1+                   , rv_lcl   = init_rn_env+                   , rv_fltR  = mkEmptySubst (rnInScopeSet init_rn_env)+                   , rv_unf   = id_unf }++    go _    subst []     _      = Just subst+    go _    _     _      []     = Nothing       -- Fail if too few actual args+    go menv subst (t:ts) (e:es) = do { subst1 <- match menv subst t e+                                     ; go menv subst1 ts es }++    lookup_tmpl :: RuleSubst -> TCvSubst -> (InVar,OutVar) -> (TCvSubst, CoreExpr)+                   -- Need to return a RuleSubst solely for the benefit of mk_fake_ty+    lookup_tmpl (RS { rs_tv_subst = tv_subst, rs_id_subst = id_subst })+                tcv_subst (tmpl_var, tmpl_var1)+        | isId tmpl_var1+        = case lookupVarEnv id_subst tmpl_var1 of+            Just e | Coercion co <- e+                   -> (Type.extendCvSubst tcv_subst tmpl_var1 co, Coercion co)+                   | otherwise+                   -> (tcv_subst, e)+            Nothing | Just refl_co <- isReflCoVar_maybe tmpl_var1+                    , let co = Coercion.substCo tcv_subst refl_co+                    -> -- See Note [Unbound RULE binders]+                       (Type.extendCvSubst tcv_subst tmpl_var1 co, Coercion co)+                    | otherwise+                    -> unbound tmpl_var++        | otherwise+        = (Type.extendTvSubst tcv_subst tmpl_var1 ty', Type ty')+        where+          ty' = case lookupVarEnv tv_subst tmpl_var1 of+                  Just ty -> ty+                  Nothing -> fake_ty   -- See Note [Unbound RULE binders]+          fake_ty = anyTypeOfKind (Type.substTy tcv_subst (tyVarKind tmpl_var1))+                    -- This substitution is the sole reason we accumulate+                    -- TCvSubst in lookup_tmpl++    unbound tmpl_var+       = pprPanic "Template variable unbound in rewrite rule" $+         vcat [ text "Variable:" <+> ppr tmpl_var <+> dcolon <+> ppr (varType tmpl_var)+              , text "Rule" <+> pprRuleName rule_name+              , text "Rule bndrs:" <+> ppr tmpl_vars+              , text "LHS args:" <+> ppr tmpl_es+              , text "Actual args:" <+> ppr target_es ]+++{- Note [Unbound RULE binders]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It can be the case that the binder in a rule is not actually+bound on the LHS:++* Type variables.  Type synonyms with phantom args can give rise to+  unbound template type variables.  Consider this (#10689,+  simplCore/should_compile/T10689):++    type Foo a b = b++    f :: Eq a => a -> Bool+    f x = x==x++    {-# RULES "foo" forall (x :: Foo a Char). f x = True #-}+    finkle = f 'c'++  The rule looks like+    forall (a::*) (d::Eq Char) (x :: Foo a Char).+         f (Foo a Char) d x = True++  Matching the rule won't bind 'a', and legitimately so.  We fudge by+  pretending that 'a' is bound to (Any :: *).++* Coercion variables.  On the LHS of a RULE for a local binder+  we might have+    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 simplify the LHS (Simplify.simplRule) we+  optCoercion (look at the CoVarCo case) 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.++  It's tricky to be sure this never happens, so instead I+  say it's OK to have an unbound coercion binder in a RULE+  provided its type is (c :: t~t).  Then, when the RULE+  fires we can substitute <t> for c.++  This actually happened (in a RULE for a local function)+  in #13410, and also in test T10602.++Note [Cloning the template binders]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider the following match (example 1):+        Template:  forall x.  f x+        Target:               f (x+1)+This should succeed, because the template variable 'x' has nothing to+do with the 'x' in the target.++Likewise this one (example 2):+        Template:  forall x. f (\x.x)+        Target:              f (\y.y)++We achieve this simply by using rnBndrL to clone the template+binders if they are already in scope.++------ Historical note -------+At one point I tried simply adding the template binders to the+in-scope set /without/ cloning them, but that failed in a horribly+obscure way in #14777.  Problem was that during matching we look+up target-term variables in the in-scope set (see Note [Lookup+in-scope]).  If a target-term variable happens to name-clash with a+template variable, that lookup will find the template variable, which+is /utterly/ bogus.  In #14777, this transformed a term variable+into a type variable, and then crashed when we wanted its idInfo.+------ End of historical note -------+++************************************************************************+*                                                                      *+                   The main matcher+*                                                                      *+********************************************************************* -}++-- * The domain of the TvSubstEnv and IdSubstEnv are the template+--   variables passed into the match.+--+-- * The BindWrapper in a RuleSubst are the bindings floated out+--   from nested matches; see the Let case of match, below+--+data RuleMatchEnv+  = RV { rv_lcl   :: RnEnv2          -- Renamings for *local bindings*+                                     --   (lambda/case)+       , rv_tmpls :: VarSet          -- Template variables+                                     --   (after applying envL of rv_lcl)+       , rv_fltR  :: Subst           -- Renamings for floated let-bindings+                                     --   (domain disjoint from envR of rv_lcl)+                                     -- See Note [Matching lets]+       , rv_unf :: IdUnfoldingFun+       }++rvInScopeEnv :: RuleMatchEnv -> InScopeEnv+rvInScopeEnv renv = (rnInScopeSet (rv_lcl renv), rv_unf renv)++data RuleSubst = RS { rs_tv_subst :: TvSubstEnv   -- Range is the+                    , rs_id_subst :: IdSubstEnv   --   template variables+                    , rs_binds    :: BindWrapper  -- Floated bindings+                    , rs_bndrs    :: VarSet       -- Variables bound by floated lets+                    }++type BindWrapper = CoreExpr -> CoreExpr+  -- See Notes [Matching lets] and [Matching cases]+  -- we represent the floated bindings as a core-to-core function++emptyRuleSubst :: RuleSubst+emptyRuleSubst = RS { rs_tv_subst = emptyVarEnv, rs_id_subst = emptyVarEnv+                    , rs_binds = \e -> e, rs_bndrs = emptyVarSet }++--      At one stage I tried to match even if there are more+--      template args than real args.++--      I now think this is probably a bad idea.+--      Should the template (map f xs) match (map g)?  I think not.+--      For a start, in general eta expansion wastes work.+--      SLPJ July 99++match :: RuleMatchEnv+      -> RuleSubst+      -> CoreExpr               -- Template+      -> CoreExpr               -- Target+      -> Maybe RuleSubst++-- We look through certain ticks. See note [Tick annotations in RULE matching]+match renv subst e1 (Tick t e2)+  | tickishFloatable t+  = match renv subst' e1 e2+  where subst' = subst { rs_binds = rs_binds subst . mkTick t }+match _ _ e@Tick{} _+  = pprPanic "Tick in rule" (ppr e)++-- See the notes with Unify.match, which matches types+-- Everything is very similar for terms++-- Interesting examples:+-- Consider matching+--      \x->f      against    \f->f+-- When we meet the lambdas we must remember to rename f to f' in the+-- second expression.  The RnEnv2 does that.+--+-- Consider matching+--      forall a. \b->b    against   \a->3+-- We must rename the \a.  Otherwise when we meet the lambdas we+-- might substitute [a/b] in the template, and then erroneously+-- succeed in matching what looks like the template variable 'a' against 3.++-- The Var case follows closely what happens in Unify.match+match renv subst (Var v1) e2+  = match_var renv subst v1 e2++match renv subst e1 (Var v2)      -- Note [Expanding variables]+  | not (inRnEnvR rn_env v2) -- Note [Do not expand locally-bound variables]+  , Just e2' <- expandUnfolding_maybe (rv_unf renv v2')+  = match (renv { rv_lcl = nukeRnEnvR rn_env }) subst e1 e2'+  where+    v2'    = lookupRnInScope rn_env v2+    rn_env = rv_lcl renv+        -- Notice that we look up v2 in the in-scope set+        -- See Note [Lookup in-scope]+        -- No need to apply any renaming first (hence no rnOccR)+        -- because of the not-inRnEnvR++match renv subst e1 (Let bind e2)+  | -- pprTrace "match:Let" (vcat [ppr bind, ppr $ okToFloat (rv_lcl renv) (bindFreeVars bind)]) $+    not (isJoinBind bind) -- can't float join point out of argument position+  , okToFloat (rv_lcl renv) (bindFreeVars bind) -- See Note [Matching lets]+  = match (renv { rv_fltR = flt_subst' })+          (subst { rs_binds = rs_binds subst . Let bind'+                 , rs_bndrs = extendVarSetList (rs_bndrs subst) new_bndrs })+          e1 e2+  where+    flt_subst = addInScopeSet (rv_fltR renv) (rs_bndrs subst)+    (flt_subst', bind') = substBind flt_subst bind+    new_bndrs = bindersOf bind'++{- Disabled: see Note [Matching cases] below+match renv (tv_subst, id_subst, binds) e1+      (Case scrut case_bndr ty [(con, alt_bndrs, rhs)])+  | exprOkForSpeculation scrut  -- See Note [Matching cases]+  , okToFloat rn_env bndrs (exprFreeVars scrut)+  = match (renv { me_env = rn_env' })+          (tv_subst, id_subst, binds . case_wrap)+          e1 rhs+  where+    rn_env   = me_env renv+    rn_env'  = extendRnInScopeList rn_env bndrs+    bndrs    = case_bndr : alt_bndrs+    case_wrap rhs' = Case scrut case_bndr ty [(con, alt_bndrs, rhs')]+-}++match _ subst (Lit lit1) (Lit lit2)+  | lit1 == lit2+  = Just subst++match renv subst (App f1 a1) (App f2 a2)+  = do  { subst' <- match renv subst f1 f2+        ; match renv subst' a1 a2 }++match renv subst (Lam x1 e1) e2+  | Just (x2, e2, ts) <- exprIsLambda_maybe (rvInScopeEnv renv) e2+  = let renv' = renv { rv_lcl = rnBndr2 (rv_lcl renv) x1 x2+                     , rv_fltR = delBndr (rv_fltR renv) x2 }+        subst' = subst { rs_binds = rs_binds subst . flip (foldr mkTick) ts }+    in  match renv' subst' e1 e2++match renv subst (Case e1 x1 ty1 alts1) (Case e2 x2 ty2 alts2)+  = do  { subst1 <- match_ty renv subst ty1 ty2+        ; subst2 <- match renv subst1 e1 e2+        ; let renv' = rnMatchBndr2 renv subst x1 x2+        ; match_alts renv' subst2 alts1 alts2   -- Alts are both sorted+        }++match renv subst (Type ty1) (Type ty2)+  = match_ty renv subst ty1 ty2+match renv subst (Coercion co1) (Coercion co2)+  = match_co renv subst co1 co2++match renv subst (Cast e1 co1) (Cast e2 co2)+  = do  { subst1 <- match_co renv subst co1 co2+        ; match renv subst1 e1 e2 }++-- Everything else fails+match _ _ _e1 _e2 = -- pprTrace "Failing at" ((text "e1:" <+> ppr _e1) $$ (text "e2:" <+> ppr _e2)) $+                    Nothing++-------------+match_co :: RuleMatchEnv+         -> RuleSubst+         -> Coercion+         -> Coercion+         -> Maybe RuleSubst+match_co renv subst co1 co2+  | Just cv <- getCoVar_maybe co1+  = match_var renv subst cv (Coercion co2)+  | Just (ty1, r1) <- isReflCo_maybe co1+  = do { (ty2, r2) <- isReflCo_maybe co2+       ; guard (r1 == r2)+       ; match_ty renv subst ty1 ty2 }+match_co renv subst co1 co2+  | Just (tc1, cos1) <- splitTyConAppCo_maybe co1+  = case splitTyConAppCo_maybe co2 of+      Just (tc2, cos2)+        |  tc1 == tc2+        -> match_cos renv subst cos1 cos2+      _ -> Nothing+match_co renv subst co1 co2+  | Just (arg1, res1) <- splitFunCo_maybe co1+  = case splitFunCo_maybe co2 of+      Just (arg2, res2)+        -> match_cos renv subst [arg1, res1] [arg2, res2]+      _ -> Nothing+match_co _ _ _co1 _co2+    -- Currently just deals with CoVarCo, TyConAppCo and Refl+#if defined(DEBUG)+  = pprTrace "match_co: needs more cases" (ppr _co1 $$ ppr _co2) Nothing+#else+  = Nothing+#endif++match_cos :: RuleMatchEnv+         -> RuleSubst+         -> [Coercion]+         -> [Coercion]+         -> Maybe RuleSubst+match_cos renv subst (co1:cos1) (co2:cos2) =+  do { subst' <- match_co renv subst co1 co2+     ; match_cos renv subst' cos1 cos2 }+match_cos _ subst [] [] = Just subst+match_cos _ _ cos1 cos2 = pprTrace "match_cos: not same length" (ppr cos1 $$ ppr cos2) Nothing++-------------+rnMatchBndr2 :: RuleMatchEnv -> RuleSubst -> Var -> Var -> RuleMatchEnv+rnMatchBndr2 renv subst x1 x2+  = renv { rv_lcl  = rnBndr2 rn_env x1 x2+         , rv_fltR = delBndr (rv_fltR renv) x2 }+  where+    rn_env = addRnInScopeSet (rv_lcl renv) (rs_bndrs subst)+    -- Typically this is a no-op, but it may matter if+    -- there are some floated let-bindings++------------------------------------------+match_alts :: RuleMatchEnv+           -> RuleSubst+           -> [CoreAlt]         -- Template+           -> [CoreAlt]         -- Target+           -> Maybe RuleSubst+match_alts _ subst [] []+  = return subst+match_alts renv subst ((c1,vs1,r1):alts1) ((c2,vs2,r2):alts2)+  | c1 == c2+  = do  { subst1 <- match renv' subst r1 r2+        ; match_alts renv subst1 alts1 alts2 }+  where+    renv' = foldl' mb renv (vs1 `zip` vs2)+    mb renv (v1,v2) = rnMatchBndr2 renv subst v1 v2++match_alts _ _ _ _+  = Nothing++------------------------------------------+okToFloat :: RnEnv2 -> VarSet -> Bool+okToFloat rn_env bind_fvs+  = allVarSet not_captured bind_fvs+  where+    not_captured fv = not (inRnEnvR rn_env fv)++------------------------------------------+match_var :: RuleMatchEnv+          -> RuleSubst+          -> Var                -- Template+          -> CoreExpr        -- Target+          -> Maybe RuleSubst+match_var renv@(RV { rv_tmpls = tmpls, rv_lcl = rn_env, rv_fltR = flt_env })+          subst v1 e2+  | v1' `elemVarSet` tmpls+  = match_tmpl_var renv subst v1' e2++  | otherwise   -- v1' is not a template variable; check for an exact match with e2+  = case e2 of  -- Remember, envR of rn_env is disjoint from rv_fltR+       Var v2 | v1' == rnOccR rn_env v2+              -> Just subst++              | Var v2' <- lookupIdSubst (text "match_var") flt_env v2+              , v1' == v2'+              -> Just subst++       _ -> Nothing++  where+    v1' = rnOccL rn_env v1+        -- If the template is+        --      forall x. f x (\x -> x) = ...+        -- Then the x inside the lambda isn't the+        -- template x, so we must rename first!++------------------------------------------+match_tmpl_var :: RuleMatchEnv+               -> RuleSubst+               -> Var                -- Template+               -> CoreExpr              -- Target+               -> Maybe RuleSubst++match_tmpl_var renv@(RV { rv_lcl = rn_env, rv_fltR = flt_env })+               subst@(RS { rs_id_subst = id_subst, rs_bndrs = let_bndrs })+               v1' e2+  | any (inRnEnvR rn_env) (exprFreeVarsList e2)+  = Nothing     -- Occurs check failure+                -- e.g. match forall a. (\x-> a x) against (\y. y y)++  | Just e1' <- lookupVarEnv id_subst v1'+  = if eqExpr (rnInScopeSet rn_env) e1' e2'+    then Just subst+    else Nothing++  | otherwise+  =             -- Note [Matching variable types]+                -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+                -- However, we must match the *types*; e.g.+                --   forall (c::Char->Int) (x::Char).+                --      f (c x) = "RULE FIRED"+                -- We must only match on args that have the right type+                -- It's actually quite difficult to come up with an example that shows+                -- you need type matching, esp since matching is left-to-right, so type+                -- args get matched first.  But it's possible (e.g. simplrun008) and+                -- this is the Right Thing to do+    do { subst' <- match_ty renv subst (idType v1') (exprType e2)+       ; return (subst' { rs_id_subst = id_subst' }) }+  where+    -- e2' is the result of applying flt_env to e2+    e2' | isEmptyVarSet let_bndrs = e2+        | otherwise = substExpr (text "match_tmpl_var") flt_env e2++    id_subst' = extendVarEnv (rs_id_subst subst) v1' e2'+         -- No further renaming to do on e2',+         -- because no free var of e2' is in the rnEnvR of the envt++------------------------------------------+match_ty :: RuleMatchEnv+         -> RuleSubst+         -> Type                -- Template+         -> Type                -- Target+         -> Maybe RuleSubst+-- Matching Core types: use the matcher in TcType.+-- Notice that we treat newtypes as opaque.  For example, suppose+-- we have a specialised version of a function at a newtype, say+--      newtype T = MkT Int+-- We only want to replace (f T) with f', not (f Int).++match_ty renv subst ty1 ty2+  = do  { tv_subst'+            <- Unify.ruleMatchTyKiX (rv_tmpls renv) (rv_lcl renv) tv_subst ty1 ty2+        ; return (subst { rs_tv_subst = tv_subst' }) }+  where+    tv_subst = rs_tv_subst subst++{-+Note [Expanding variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~+Here is another Very Important rule: if the term being matched is a+variable, we expand it so long as its unfolding is "expandable". (Its+occurrence information is not necessarily up to date, so we don't use+it.)  By "expandable" we mean a WHNF or a "constructor-like" application.+This is the key reason for "constructor-like" Ids.  If we have+     {-# NOINLINE [1] CONLIKE g #-}+     {-# RULE f (g x) = h x #-}+then in the term+   let v = g 3 in ....(f v)....+we want to make the rule fire, to replace (f v) with (h 3).++Note [Do not expand locally-bound variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Do *not* expand locally-bound variables, else there's a worry that the+unfolding might mention variables that are themselves renamed.+Example+          case x of y { (p,q) -> ...y... }+Don't expand 'y' to (p,q) because p,q might themselves have been+renamed.  Essentially we only expand unfoldings that are "outside"+the entire match.++Hence, (a) the guard (not (isLocallyBoundR v2))+       (b) when we expand we nuke the renaming envt (nukeRnEnvR).++Note [Tick annotations in RULE matching]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++We used to unconditionally look through Notes in both template and+expression being matched. This is actually illegal for counting or+cost-centre-scoped ticks, because we have no place to put them without+changing entry counts and/or costs. So now we just fail the match in+these cases.++On the other hand, where we are allowed to insert new cost into the+tick scope, we can float them upwards to the rule application site.++cf Note [Notes in call patterns] in SpecConstr++Note [Matching lets]+~~~~~~~~~~~~~~~~~~~~+Matching a let-expression.  Consider+        RULE forall x.  f (g x) = <rhs>+and target expression+        f (let { w=R } in g E))+Then we'd like the rule to match, to generate+        let { w=R } in (\x. <rhs>) E+In effect, we want to float the let-binding outward, to enable+the match to happen.  This is the WHOLE REASON for accumulating+bindings in the RuleSubst++We can only do this if the free variables of R are not bound by the+part of the target expression outside the let binding; e.g.+        f (\v. let w = v+1 in g E)+Here we obviously cannot float the let-binding for w.  Hence the+use of okToFloat.++There are a couple of tricky points.+  (a) What if floating the binding captures a variable?+        f (let v = x+1 in v) v+      --> NOT!+        let v = x+1 in f (x+1) v++  (b) What if two non-nested let bindings bind the same variable?+        f (let v = e1 in b1) (let v = e2 in b2)+      --> NOT!+        let v = e1 in let v = e2 in (f b2 b2)+      See testsuite test "RuleFloatLet".++Our cunning plan is this:+  * Along with the growing substitution for template variables+    we maintain a growing set of floated let-bindings (rs_binds)+    plus the set of variables thus bound.++  * The RnEnv2 in the MatchEnv binds only the local binders+    in the term (lambdas, case)++  * When we encounter a let in the term to be matched, we+    check that does not mention any locally bound (lambda, case)+    variables.  If so we fail++  * We use GHC.Core.Subst.substBind to freshen the binding, using an+    in-scope set that is the original in-scope variables plus the+    rs_bndrs (currently floated let-bindings).  So in (a) above+    we'll freshen the 'v' binding; in (b) above we'll freshen+    the *second* 'v' binding.++  * We apply that freshening substitution, in a lexically-scoped+    way to the term, although lazily; this is the rv_fltR field.+++Note [Matching cases]+~~~~~~~~~~~~~~~~~~~~~+{- NOTE: This idea is currently disabled.  It really only works if+         the primops involved are OkForSpeculation, and, since+         they have side effects readIntOfAddr and touch are not.+         Maybe we'll get back to this later .  -}++Consider+   f (case readIntOffAddr# p# i# realWorld# of { (# s#, n# #) ->+      case touch# fp s# of { _ ->+      I# n# } } )+This happened in a tight loop generated by stream fusion that+Roman encountered.  We'd like to treat this just like the let+case, because the primops concerned are ok-for-speculation.+That is, we'd like to behave as if it had been+   case readIntOffAddr# p# i# realWorld# of { (# s#, n# #) ->+   case touch# fp s# of { _ ->+   f (I# n# } } )++Note [Lookup in-scope]+~~~~~~~~~~~~~~~~~~~~~~+Consider this example+        foo :: Int -> Maybe Int -> Int+        foo 0 (Just n) = n+        foo m (Just n) = foo (m-n) (Just n)++SpecConstr sees this fragment:++        case w_smT of wild_Xf [Just A] {+          Data.Maybe.Nothing -> lvl_smf;+          Data.Maybe.Just n_acT [Just S(L)] ->+            case n_acT of wild1_ams [Just A] { GHC.Base.I# y_amr [Just L] ->+              $wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf+            }};++and correctly generates the rule++        RULES: "SC:$wfoo1" [0] __forall {y_amr [Just L] :: GHC.Prim.Int#+                                          sc_snn :: GHC.Prim.Int#}+          $wfoo_smW sc_snn (Data.Maybe.Just @ GHC.Base.Int (GHC.Base.I# y_amr))+          = $s$wfoo_sno y_amr sc_snn ;]++BUT we must ensure that this rule matches in the original function!+Note that the call to $wfoo is+            $wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf++During matching we expand wild_Xf to (Just n_acT).  But then we must also+expand n_acT to (I# y_amr).  And we can only do that if we look up n_acT+in the in-scope set, because in wild_Xf's unfolding it won't have an unfolding+at all.++That is why the 'lookupRnInScope' call in the (Var v2) case of 'match'+is so important.+++************************************************************************+*                                                                      *+                   Rule-check the program+*                                                                      *+************************************************************************++   We want to know what sites have rules that could have fired but didn't.+   This pass runs over the tree (without changing it) and reports such.+-}++-- | Report partial matches for rules beginning with the specified+-- string for the purposes of error reporting+ruleCheckProgram :: CompilerPhase               -- ^ Rule activation test+                 -> String                      -- ^ Rule pattern+                 -> (Id -> [CoreRule])          -- ^ Rules for an Id+                 -> CoreProgram                 -- ^ Bindings to check in+                 -> SDoc                        -- ^ Resulting check message+ruleCheckProgram phase rule_pat rules binds+  | isEmptyBag results+  = text "Rule check results: no rule application sites"+  | otherwise+  = vcat [text "Rule check results:",+          line,+          vcat [ p $$ line | p <- bagToList results ]+         ]+  where+    env = RuleCheckEnv { rc_is_active = isActive phase+                       , rc_id_unf    = idUnfolding     -- Not quite right+                                                        -- Should use activeUnfolding+                       , rc_pattern   = rule_pat+                       , rc_rules = rules }+    results = unionManyBags (map (ruleCheckBind env) binds)+    line = text (replicate 20 '-')++data RuleCheckEnv = RuleCheckEnv {+    rc_is_active :: Activation -> Bool,+    rc_id_unf  :: IdUnfoldingFun,+    rc_pattern :: String,+    rc_rules :: Id -> [CoreRule]+}++ruleCheckBind :: RuleCheckEnv -> CoreBind -> Bag SDoc+   -- The Bag returned has one SDoc for each call site found+ruleCheckBind env (NonRec _ r) = ruleCheck env r+ruleCheckBind env (Rec prs)    = unionManyBags [ruleCheck env r | (_,r) <- prs]++ruleCheck :: RuleCheckEnv -> CoreExpr -> Bag SDoc+ruleCheck _   (Var _)       = emptyBag+ruleCheck _   (Lit _)       = emptyBag+ruleCheck _   (Type _)      = emptyBag+ruleCheck _   (Coercion _)  = emptyBag+ruleCheck env (App f a)     = ruleCheckApp env (App f a) []+ruleCheck env (Tick _ e)  = ruleCheck env e+ruleCheck env (Cast e _)    = ruleCheck env e+ruleCheck env (Let bd e)    = ruleCheckBind env bd `unionBags` ruleCheck env e+ruleCheck env (Lam _ e)     = ruleCheck env e+ruleCheck env (Case e _ _ as) = ruleCheck env e `unionBags`+                                unionManyBags [ruleCheck env r | (_,_,r) <- as]++ruleCheckApp :: RuleCheckEnv -> Expr CoreBndr -> [Arg CoreBndr] -> Bag SDoc+ruleCheckApp env (App f a) as = ruleCheck env a `unionBags` ruleCheckApp env f (a:as)+ruleCheckApp env (Var f) as   = ruleCheckFun env f as+ruleCheckApp env other _      = ruleCheck env other++ruleCheckFun :: RuleCheckEnv -> Id -> [CoreExpr] -> Bag SDoc+-- Produce a report for all rules matching the predicate+-- saying why it doesn't match the specified application++ruleCheckFun env fn args+  | null name_match_rules = emptyBag+  | otherwise             = unitBag (ruleAppCheck_help env fn args name_match_rules)+  where+    name_match_rules = filter match (rc_rules env fn)+    match rule = (rc_pattern env) `isPrefixOf` unpackFS (ruleName rule)++ruleAppCheck_help :: RuleCheckEnv -> Id -> [CoreExpr] -> [CoreRule] -> SDoc+ruleAppCheck_help env fn args rules+  =     -- The rules match the pattern, so we want to print something+    vcat [text "Expression:" <+> ppr (mkApps (Var fn) args),+          vcat (map check_rule rules)]+  where+    n_args = length args+    i_args = args `zip` [1::Int ..]+    rough_args = map roughTopName args++    check_rule rule = sdocWithDynFlags $ \dflags ->+                      rule_herald rule <> colon <+> rule_info dflags rule++    rule_herald (BuiltinRule { ru_name = name })+        = text "Builtin rule" <+> doubleQuotes (ftext name)+    rule_herald (Rule { ru_name = name })+        = text "Rule" <+> doubleQuotes (ftext name)++    rule_info dflags rule+        | Just _ <- matchRule dflags (emptyInScopeSet, rc_id_unf env)+                              noBlackList fn args rough_args rule+        = text "matches (which is very peculiar!)"++    rule_info _ (BuiltinRule {}) = text "does not match"++    rule_info _ (Rule { ru_act = act,+                        ru_bndrs = rule_bndrs, ru_args = rule_args})+        | not (rc_is_active env act)  = text "active only in later phase"+        | n_args < n_rule_args        = text "too few arguments"+        | n_mismatches == n_rule_args = text "no arguments match"+        | n_mismatches == 0           = text "all arguments match (considered individually), but rule as a whole does not"+        | otherwise                   = text "arguments" <+> ppr mismatches <+> text "do not match (1-indexing)"+        where+          n_rule_args  = length rule_args+          n_mismatches = length mismatches+          mismatches   = [i | (rule_arg, (arg,i)) <- rule_args `zip` i_args,+                              not (isJust (match_fn rule_arg arg))]++          lhs_fvs = exprsFreeVars rule_args     -- Includes template tyvars+          match_fn rule_arg arg = match renv emptyRuleSubst rule_arg arg+                where+                  in_scope = mkInScopeSet (lhs_fvs `unionVarSet` exprFreeVars arg)+                  renv = RV { rv_lcl   = mkRnEnv2 in_scope+                            , rv_tmpls = mkVarSet rule_bndrs+                            , rv_fltR  = mkEmptySubst in_scope+                            , rv_unf   = rc_id_unf env }

+ compiler/GHC/Core/Seq.hs view

@@ -0,0 +1,115 @@+-- |+-- Various utilities for forcing Core structures+--+-- It can often be useful to force various parts of the AST. This module+-- provides a number of @seq@-like functions to accomplish this.++module GHC.Core.Seq (+        -- * Utilities for forcing Core structures+        seqExpr, seqExprs, seqUnfolding, seqRules,+        megaSeqIdInfo, seqRuleInfo, seqBinds,+    ) where++import GhcPrelude++import GHC.Core+import IdInfo+import Demand( seqDemand, seqStrictSig )+import Cpr( seqCprSig )+import BasicTypes( seqOccInfo )+import VarSet( seqDVarSet )+import Var( varType, tyVarKind )+import Type( seqType, isTyVar )+import Coercion( seqCo )+import Id( Id, idInfo )++-- | Evaluate all the fields of the 'IdInfo' that are generally demanded by the+-- compiler+megaSeqIdInfo :: IdInfo -> ()+megaSeqIdInfo info+  = seqRuleInfo (ruleInfo info)                 `seq`++-- Omitting this improves runtimes a little, presumably because+-- some unfoldings are not calculated at all+--    seqUnfolding (unfoldingInfo info)         `seq`++    seqDemand (demandInfo info)                 `seq`+    seqStrictSig (strictnessInfo info)          `seq`+    seqCprSig (cprInfo info)                    `seq`+    seqCaf (cafInfo info)                       `seq`+    seqOneShot (oneShotInfo info)               `seq`+    seqOccInfo (occInfo info)++seqOneShot :: OneShotInfo -> ()+seqOneShot l = l `seq` ()++seqRuleInfo :: RuleInfo -> ()+seqRuleInfo (RuleInfo rules fvs) = seqRules rules `seq` seqDVarSet fvs++seqCaf :: CafInfo -> ()+seqCaf c = c `seq` ()++seqRules :: [CoreRule] -> ()+seqRules [] = ()+seqRules (Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs } : rules)+  = seqBndrs bndrs `seq` seqExprs (rhs:args) `seq` seqRules rules+seqRules (BuiltinRule {} : rules) = seqRules rules++seqExpr :: CoreExpr -> ()+seqExpr (Var v)         = v `seq` ()+seqExpr (Lit lit)       = lit `seq` ()+seqExpr (App f a)       = seqExpr f `seq` seqExpr a+seqExpr (Lam b e)       = seqBndr b `seq` seqExpr e+seqExpr (Let b e)       = seqBind b `seq` seqExpr e+seqExpr (Case e b t as) = seqExpr e `seq` seqBndr b `seq` seqType t `seq` seqAlts as+seqExpr (Cast e co)     = seqExpr e `seq` seqCo co+seqExpr (Tick n e)      = seqTickish n `seq` seqExpr e+seqExpr (Type t)        = seqType t+seqExpr (Coercion co)   = seqCo co++seqExprs :: [CoreExpr] -> ()+seqExprs [] = ()+seqExprs (e:es) = seqExpr e `seq` seqExprs es++seqTickish :: Tickish Id -> ()+seqTickish ProfNote{ profNoteCC = cc } = cc `seq` ()+seqTickish HpcTick{} = ()+seqTickish Breakpoint{ breakpointFVs = ids } = seqBndrs ids+seqTickish SourceNote{} = ()++seqBndr :: CoreBndr -> ()+seqBndr b | isTyVar b = seqType (tyVarKind b)+          | otherwise = seqType (varType b)             `seq`+                        megaSeqIdInfo (idInfo b)++seqBndrs :: [CoreBndr] -> ()+seqBndrs [] = ()+seqBndrs (b:bs) = seqBndr b `seq` seqBndrs bs++seqBinds :: [Bind CoreBndr] -> ()+seqBinds bs = foldr (seq . seqBind) () bs++seqBind :: Bind CoreBndr -> ()+seqBind (NonRec b e) = seqBndr b `seq` seqExpr e+seqBind (Rec prs)    = seqPairs prs++seqPairs :: [(CoreBndr, CoreExpr)] -> ()+seqPairs [] = ()+seqPairs ((b,e):prs) = seqBndr b `seq` seqExpr e `seq` seqPairs prs++seqAlts :: [CoreAlt] -> ()+seqAlts [] = ()+seqAlts ((c,bs,e):alts) = c `seq` seqBndrs bs `seq` seqExpr e `seq` seqAlts alts++seqUnfolding :: Unfolding -> ()+seqUnfolding (CoreUnfolding { uf_tmpl = e, uf_is_top = top,+                uf_is_value = b1, uf_is_work_free = b2,+                uf_expandable = b3, uf_is_conlike = b4,+                uf_guidance = g})+  = seqExpr e `seq` top `seq` b1 `seq` b2 `seq` b3 `seq` b4 `seq` seqGuidance g++seqUnfolding _ = ()++seqGuidance :: UnfoldingGuidance -> ()+seqGuidance (UnfIfGoodArgs ns n b) = n `seq` sum ns `seq` b `seq` ()+seqGuidance _                      = ()

+ compiler/GHC/Core/SimpleOpt.hs view

@@ -0,0 +1,1475 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+-}++{-# LANGUAGE CPP #-}+module GHC.Core.SimpleOpt (+        -- ** Simple expression optimiser+        simpleOptPgm, simpleOptExpr, simpleOptExprWith,++        -- ** Join points+        joinPointBinding_maybe, joinPointBindings_maybe,++        -- ** Predicates on expressions+        exprIsConApp_maybe, exprIsLiteral_maybe, exprIsLambda_maybe,++        -- ** Coercions and casts+        pushCoArg, pushCoValArg, pushCoTyArg, collectBindersPushingCo+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Core.Arity( etaExpandToJoinPoint )++import GHC.Core+import GHC.Core.Subst+import GHC.Core.Utils+import GHC.Core.FVs+import {-# SOURCE #-} GHC.Core.Unfold( mkUnfolding )+import GHC.Core.Make ( FloatBind(..) )+import GHC.Core.Ppr  ( pprCoreBindings, pprRules )+import OccurAnal( occurAnalyseExpr, occurAnalysePgm )+import Literal  ( Literal(LitString) )+import Id+import IdInfo   ( unfoldingInfo, setUnfoldingInfo, setRuleInfo, IdInfo (..) )+import Var      ( isNonCoVarId )+import VarSet+import VarEnv+import DataCon+import Demand( etaExpandStrictSig )+import OptCoercion ( optCoercion )+import Type     hiding ( substTy, extendTvSubst, extendCvSubst, extendTvSubstList+                       , isInScope, substTyVarBndr, cloneTyVarBndr )+import Coercion hiding ( substCo, substCoVarBndr )+import TyCon        ( tyConArity )+import TysWiredIn+import PrelNames+import BasicTypes+import Module       ( Module )+import ErrUtils+import GHC.Driver.Session+import Outputable+import Pair+import Util+import Maybes       ( orElse )+import FastString+import Data.List+import qualified Data.ByteString as BS++{-+************************************************************************+*                                                                      *+        The Simple Optimiser+*                                                                      *+************************************************************************++Note [The simple optimiser]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+The simple optimiser is a lightweight, pure (non-monadic) function+that rapidly does a lot of simple optimisations, including++  - inlining things that occur just once,+      or whose RHS turns out to be trivial+  - beta reduction+  - case of known constructor+  - dead code elimination++It does NOT do any call-site inlining; it only inlines a function if+it can do so unconditionally, dropping the binding.  It thereby+guarantees to leave no un-reduced beta-redexes.++It is careful to follow the guidance of "Secrets of the GHC inliner",+and in particular the pre-inline-unconditionally and+post-inline-unconditionally story, to do effective beta reduction on+functions called precisely once, without repeatedly optimising the same+expression.  In fact, the simple optimiser is a good example of this+little dance in action; the full Simplifier is a lot more complicated.++-}++simpleOptExpr :: DynFlags -> CoreExpr -> CoreExpr+-- See Note [The simple optimiser]+-- Do simple optimisation on an expression+-- The optimisation is very straightforward: just+-- inline non-recursive bindings that are used only once,+-- or where the RHS is trivial+--+-- We also inline bindings that bind a Eq# box: see+-- See Note [Getting the map/coerce RULE to work].+--+-- Also we convert functions to join points where possible (as+-- the occurrence analyser does most of the work anyway).+--+-- The result is NOT guaranteed occurrence-analysed, because+-- in  (let x = y in ....) we substitute for x; so y's occ-info+-- may change radically++simpleOptExpr dflags expr+  = -- pprTrace "simpleOptExpr" (ppr init_subst $$ ppr expr)+    simpleOptExprWith dflags init_subst expr+  where+    init_subst = mkEmptySubst (mkInScopeSet (exprFreeVars expr))+        -- It's potentially important to make a proper in-scope set+        -- Consider  let x = ..y.. in \y. ...x...+        -- Then we should remember to clone y before substituting+        -- for x.  It's very unlikely to occur, because we probably+        -- won't *be* substituting for x if it occurs inside a+        -- lambda.+        --+        -- It's a bit painful to call exprFreeVars, because it makes+        -- three passes instead of two (occ-anal, and go)++simpleOptExprWith :: DynFlags -> Subst -> InExpr -> OutExpr+-- See Note [The simple optimiser]+simpleOptExprWith dflags subst expr+  = simple_opt_expr init_env (occurAnalyseExpr expr)+  where+    init_env = SOE { soe_dflags = dflags+                   , soe_inl = emptyVarEnv+                   , soe_subst = subst }++----------------------+simpleOptPgm :: DynFlags -> Module+             -> CoreProgram -> [CoreRule]+             -> IO (CoreProgram, [CoreRule])+-- See Note [The simple optimiser]+simpleOptPgm dflags this_mod binds rules+  = do { dumpIfSet_dyn dflags Opt_D_dump_occur_anal "Occurrence analysis"+            FormatCore (pprCoreBindings occ_anald_binds $$ pprRules rules );++       ; return (reverse binds', rules') }+  where+    occ_anald_binds  = occurAnalysePgm this_mod+                          (\_ -> True)  {- All unfoldings active -}+                          (\_ -> False) {- No rules active -}+                          rules binds++    (final_env, binds') = foldl' do_one (emptyEnv dflags, []) occ_anald_binds+    final_subst = soe_subst final_env++    rules' = substRulesForImportedIds final_subst rules+             -- We never unconditionally inline into rules,+             -- hence paying just a substitution++    do_one (env, binds') bind+      = case simple_opt_bind env bind TopLevel of+          (env', Nothing)    -> (env', binds')+          (env', Just bind') -> (env', bind':binds')++-- In these functions the substitution maps InVar -> OutExpr++----------------------+type SimpleClo = (SimpleOptEnv, InExpr)++data SimpleOptEnv+  = SOE { soe_dflags :: DynFlags+        , soe_inl   :: IdEnv SimpleClo+             -- Deals with preInlineUnconditionally; things+             -- that occur exactly once and are inlined+             -- without having first been simplified++        , soe_subst :: Subst+             -- Deals with cloning; includes the InScopeSet+        }++instance Outputable SimpleOptEnv where+  ppr (SOE { soe_inl = inl, soe_subst = subst })+    = text "SOE {" <+> vcat [ text "soe_inl   =" <+> ppr inl+                            , text "soe_subst =" <+> ppr subst ]+                   <+> text "}"++emptyEnv :: DynFlags -> SimpleOptEnv+emptyEnv dflags+  = SOE { soe_dflags = dflags+        , soe_inl = emptyVarEnv+        , soe_subst = emptySubst }++soeZapSubst :: SimpleOptEnv -> SimpleOptEnv+soeZapSubst env@(SOE { soe_subst = subst })+  = env { soe_inl = emptyVarEnv, soe_subst = zapSubstEnv subst }++soeSetInScope :: SimpleOptEnv -> SimpleOptEnv -> SimpleOptEnv+-- Take in-scope set from env1, and the rest from env2+soeSetInScope (SOE { soe_subst = subst1 })+              env2@(SOE { soe_subst = subst2 })+  = env2 { soe_subst = setInScope subst2 (substInScope subst1) }++---------------+simple_opt_clo :: SimpleOptEnv -> SimpleClo -> OutExpr+simple_opt_clo env (e_env, e)+  = simple_opt_expr (soeSetInScope env e_env) e++simple_opt_expr :: HasCallStack => SimpleOptEnv -> InExpr -> OutExpr+simple_opt_expr env expr+  = go expr+  where+    subst        = soe_subst env+    in_scope     = substInScope subst+    in_scope_env = (in_scope, simpleUnfoldingFun)++    go (Var v)+       | Just clo <- lookupVarEnv (soe_inl env) v+       = simple_opt_clo env clo+       | otherwise+       = lookupIdSubst (text "simpleOptExpr") (soe_subst env) v++    go (App e1 e2)      = simple_app env e1 [(env,e2)]+    go (Type ty)        = Type     (substTy subst ty)+    go (Coercion co)    = Coercion (optCoercion (soe_dflags env) (getTCvSubst subst) co)+    go (Lit lit)        = Lit lit+    go (Tick tickish e) = mkTick (substTickish subst tickish) (go e)+    go (Cast e co)      | isReflCo co' = go e+                        | otherwise    = Cast (go e) co'+                        where+                          co' = optCoercion (soe_dflags env) (getTCvSubst subst) co++    go (Let bind body)  = case simple_opt_bind env bind NotTopLevel of+                             (env', Nothing)   -> simple_opt_expr env' body+                             (env', Just bind) -> Let bind (simple_opt_expr env' body)++    go lam@(Lam {})     = go_lam env [] lam+    go (Case e b ty as)+       -- See Note [Getting the map/coerce RULE to work]+      | isDeadBinder b+      , Just (_, [], con, _tys, es) <- exprIsConApp_maybe in_scope_env e'+        -- We don't need to be concerned about floats when looking for coerce.+      , Just (altcon, bs, rhs) <- findAlt (DataAlt con) as+      = case altcon of+          DEFAULT -> go rhs+          _       -> foldr wrapLet (simple_opt_expr env' rhs) mb_prs+            where+              (env', mb_prs) = mapAccumL (simple_out_bind NotTopLevel) env $+                               zipEqual "simpleOptExpr" bs es++         -- Note [Getting the map/coerce RULE to work]+      | isDeadBinder b+      , [(DEFAULT, _, rhs)] <- as+      , isCoVarType (varType b)+      , (Var fun, _args) <- collectArgs e+      , fun `hasKey` coercibleSCSelIdKey+         -- without this last check, we get #11230+      = go rhs++      | otherwise+      = Case e' b' (substTy subst ty)+                   (map (go_alt env') as)+      where+        e' = go e+        (env', b') = subst_opt_bndr env b++    ----------------------+    go_alt env (con, bndrs, rhs)+      = (con, bndrs', simple_opt_expr env' rhs)+      where+        (env', bndrs') = subst_opt_bndrs env bndrs++    ----------------------+    -- go_lam tries eta reduction+    go_lam env bs' (Lam b e)+       = go_lam env' (b':bs') e+       where+         (env', b') = subst_opt_bndr env b+    go_lam env bs' e+       | Just etad_e <- tryEtaReduce bs e' = etad_e+       | otherwise                         = mkLams bs e'+       where+         bs = reverse bs'+         e' = simple_opt_expr env e++----------------------+-- simple_app collects arguments for beta reduction+simple_app :: SimpleOptEnv -> InExpr -> [SimpleClo] -> CoreExpr++simple_app env (Var v) as+  | Just (env', e) <- lookupVarEnv (soe_inl env) v+  = simple_app (soeSetInScope env env') e as++  | let unf = idUnfolding v+  , isCompulsoryUnfolding (idUnfolding v)+  , isAlwaysActive (idInlineActivation v)+    -- See Note [Unfold compulsory unfoldings in LHSs]+  = simple_app (soeZapSubst env) (unfoldingTemplate unf) as++  | otherwise+  , let out_fn = lookupIdSubst (text "simple_app") (soe_subst env) v+  = finish_app env out_fn as++simple_app env (App e1 e2) as+  = simple_app env e1 ((env, e2) : as)++simple_app env (Lam b e) (a:as)+  = wrapLet mb_pr (simple_app env' e as)+  where+     (env', mb_pr) = simple_bind_pair env b Nothing a NotTopLevel++simple_app env (Tick t e) as+  -- Okay to do "(Tick t e) x ==> Tick t (e x)"?+  | t `tickishScopesLike` SoftScope+  = mkTick t $ simple_app env e as++-- (let x = e in b) a1 .. an  =>  let x = e in (b a1 .. an)+-- The let might appear there as a result of inlining+-- e.g.   let f = let x = e in b+--        in f a1 a2+--   (#13208)+-- However, do /not/ do this transformation for join points+--    See Note [simple_app and join points]+simple_app env (Let bind body) args+  = case simple_opt_bind env bind NotTopLevel of+      (env', Nothing)   -> simple_app env' body args+      (env', Just bind')+        | isJoinBind bind' -> finish_app env expr' args+        | otherwise        -> Let bind' (simple_app env' body args)+        where+          expr' = Let bind' (simple_opt_expr env' body)++simple_app env e as+  = finish_app env (simple_opt_expr env e) as++finish_app :: SimpleOptEnv -> OutExpr -> [SimpleClo] -> OutExpr+finish_app _ fun []+  = fun+finish_app env fun (arg:args)+  = finish_app env (App fun (simple_opt_clo env arg)) args++----------------------+simple_opt_bind :: SimpleOptEnv -> InBind -> TopLevelFlag+                -> (SimpleOptEnv, Maybe OutBind)+simple_opt_bind env (NonRec b r) top_level+  = (env', case mb_pr of+            Nothing    -> Nothing+            Just (b,r) -> Just (NonRec b r))+  where+    (b', r') = joinPointBinding_maybe b r `orElse` (b, r)+    (env', mb_pr) = simple_bind_pair env b' Nothing (env,r') top_level++simple_opt_bind env (Rec prs) top_level+  = (env'', res_bind)+  where+    res_bind          = Just (Rec (reverse rev_prs'))+    prs'              = joinPointBindings_maybe prs `orElse` prs+    (env', bndrs')    = subst_opt_bndrs env (map fst prs')+    (env'', rev_prs') = foldl' do_pr (env', []) (prs' `zip` bndrs')+    do_pr (env, prs) ((b,r), b')+       = (env', case mb_pr of+                  Just pr -> pr : prs+                  Nothing -> prs)+       where+         (env', mb_pr) = simple_bind_pair env b (Just b') (env,r) top_level++----------------------+simple_bind_pair :: SimpleOptEnv+                 -> InVar -> Maybe OutVar+                 -> SimpleClo+                 -> TopLevelFlag+                 -> (SimpleOptEnv, Maybe (OutVar, OutExpr))+    -- (simple_bind_pair subst in_var out_rhs)+    --   either extends subst with (in_var -> out_rhs)+    --   or     returns Nothing+simple_bind_pair env@(SOE { soe_inl = inl_env, soe_subst = subst })+                 in_bndr mb_out_bndr clo@(rhs_env, in_rhs)+                 top_level+  | Type ty <- in_rhs        -- let a::* = TYPE ty in <body>+  , let out_ty = substTy (soe_subst rhs_env) ty+  = ASSERT( isTyVar in_bndr )+    (env { soe_subst = extendTvSubst subst in_bndr out_ty }, Nothing)++  | Coercion co <- in_rhs+  , let out_co = optCoercion (soe_dflags env) (getTCvSubst (soe_subst rhs_env)) co+  = ASSERT( isCoVar in_bndr )+    (env { soe_subst = extendCvSubst subst in_bndr out_co }, Nothing)++  | ASSERT2( isNonCoVarId in_bndr, ppr in_bndr )+    -- The previous two guards got rid of tyvars and coercions+    -- See Note [Core type and coercion invariant] in GHC.Core+    pre_inline_unconditionally+  = (env { soe_inl = extendVarEnv inl_env in_bndr clo }, Nothing)++  | otherwise+  = simple_out_bind_pair env in_bndr mb_out_bndr out_rhs+                         occ active stable_unf top_level+  where+    stable_unf = isStableUnfolding (idUnfolding in_bndr)+    active     = isAlwaysActive (idInlineActivation in_bndr)+    occ        = idOccInfo in_bndr++    out_rhs | Just join_arity <- isJoinId_maybe in_bndr+            = simple_join_rhs join_arity+            | otherwise+            = simple_opt_clo env clo++    simple_join_rhs join_arity -- See Note [Preserve join-binding arity]+      = mkLams join_bndrs' (simple_opt_expr env_body join_body)+      where+        env0 = soeSetInScope env rhs_env+        (join_bndrs, join_body) = collectNBinders join_arity in_rhs+        (env_body, join_bndrs') = subst_opt_bndrs env0 join_bndrs++    pre_inline_unconditionally :: Bool+    pre_inline_unconditionally+       | isExportedId in_bndr     = False+       | stable_unf               = False+       | not active               = False    -- Note [Inline prag in simplOpt]+       | not (safe_to_inline occ) = False+       | otherwise                = True++        -- Unconditionally safe to inline+    safe_to_inline :: OccInfo -> Bool+    safe_to_inline IAmALoopBreaker{}                  = False+    safe_to_inline IAmDead                            = True+    safe_to_inline OneOcc{ occ_in_lam = NotInsideLam+                         , occ_one_br = InOneBranch } = True+    safe_to_inline OneOcc{}                           = False+    safe_to_inline ManyOccs{}                         = False++-------------------+simple_out_bind :: TopLevelFlag+                -> SimpleOptEnv+                -> (InVar, OutExpr)+                -> (SimpleOptEnv, Maybe (OutVar, OutExpr))+simple_out_bind top_level env@(SOE { soe_subst = subst }) (in_bndr, out_rhs)+  | Type out_ty <- out_rhs+  = ASSERT( isTyVar in_bndr )+    (env { soe_subst = extendTvSubst subst in_bndr out_ty }, Nothing)++  | Coercion out_co <- out_rhs+  = ASSERT( isCoVar in_bndr )+    (env { soe_subst = extendCvSubst subst in_bndr out_co }, Nothing)++  | otherwise+  = simple_out_bind_pair env in_bndr Nothing out_rhs+                         (idOccInfo in_bndr) True False top_level++-------------------+simple_out_bind_pair :: SimpleOptEnv+                     -> InId -> Maybe OutId -> OutExpr+                     -> OccInfo -> Bool -> Bool -> TopLevelFlag+                     -> (SimpleOptEnv, Maybe (OutVar, OutExpr))+simple_out_bind_pair env in_bndr mb_out_bndr out_rhs+                     occ_info active stable_unf top_level+  | ASSERT2( isNonCoVarId in_bndr, ppr in_bndr )+    -- Type and coercion bindings are caught earlier+    -- See Note [Core type and coercion invariant]+    post_inline_unconditionally+  = ( env' { soe_subst = extendIdSubst (soe_subst env) in_bndr out_rhs }+    , Nothing)++  | otherwise+  = ( env', Just (out_bndr, out_rhs) )+  where+    (env', bndr1) = case mb_out_bndr of+                      Just out_bndr -> (env, out_bndr)+                      Nothing       -> subst_opt_bndr env in_bndr+    out_bndr = add_info env' in_bndr top_level out_rhs bndr1++    post_inline_unconditionally :: Bool+    post_inline_unconditionally+       | isExportedId in_bndr  = False -- Note [Exported Ids and trivial RHSs]+       | stable_unf            = False -- Note [Stable unfoldings and postInlineUnconditionally]+       | not active            = False --     in SimplUtils+       | is_loop_breaker       = False -- If it's a loop-breaker of any kind, don't inline+                                       -- because it might be referred to "earlier"+       | exprIsTrivial out_rhs = True+       | coercible_hack        = True+       | otherwise             = False++    is_loop_breaker = isWeakLoopBreaker occ_info++    -- See Note [Getting the map/coerce RULE to work]+    coercible_hack | (Var fun, args) <- collectArgs out_rhs+                   , Just dc <- isDataConWorkId_maybe fun+                   , dc `hasKey` heqDataConKey || dc `hasKey` coercibleDataConKey+                   = all exprIsTrivial args+                   | otherwise+                   = False++{- Note [Exported Ids and trivial RHSs]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We obviously do not want to unconditionally inline an Id that is exported.+In SimplUtils, Note [Top level and postInlineUnconditionally], we+explain why we don't inline /any/ top-level things unconditionally, even+trivial ones.  But we do here!  Why?  In the simple optimiser++  * We do no rule rewrites+  * We do no call-site inlining++Those differences obviate the reasons for not inlining a trivial rhs,+and increase the benefit for doing so.  So we unconditionally inline trivial+rhss here.++Note [Preserve join-binding arity]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Be careful /not/ to eta-reduce the RHS of a join point, lest we lose+the join-point arity invariant.  #15108 was caused by simplifying+the RHS with simple_opt_expr, which does eta-reduction.  Solution:+simplify the RHS of a join point by simplifying under the lambdas+(which of course should be there).++Note [simple_app and join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In general for let-bindings we can do this:+   (let { x = e } in b) a  ==>  let { x = e } in b a++But not for join points!  For two reasons:++- We would need to push the continuation into the RHS:+   (join { j = e } in b) a  ==>  let { j' = e a } in b[j'/j] a+                                      NB ----^^+  and also change the type of j, hence j'.+  That's a bit sophisticated for the very simple optimiser.++- We might end up with something like+    join { j' = e a } in+    (case blah of        )+    (  True  -> j' void# ) a+    (  False -> blah     )+  and now the call to j' doesn't look like a tail call, and+  Lint may reject.  I say "may" because this is /explicitly/+  allowed in the "Compiling without Continuations" paper+  (Section 3, "Managing \Delta").  But GHC currently does not+  allow this slightly-more-flexible form.  See GHC.Core+  Note [Join points are less general than the paper].++The simple thing to do is to disable this transformation+for join points in the simple optimiser++Note [The Let-Unfoldings Invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A program has the Let-Unfoldings property iff:++- For every let-bound variable f, whether top-level or nested, whether+  recursive or not:+  - Both the binding Id of f, and every occurrence Id of f, has an idUnfolding.+  - For non-INLINE things, that unfolding will be f's right hand sids+  - For INLINE things (which have a "stable" unfolding) that unfolding is+    semantically equivalent to f's RHS, but derived from the original RHS of f+    rather that its current RHS.++Informally, we can say that in a program that has the Let-Unfoldings property,+all let-bound Id's have an explicit unfolding attached to them.++Currently, the simplifier guarantees the Let-Unfoldings invariant for anything+it outputs.++-}++----------------------+subst_opt_bndrs :: SimpleOptEnv -> [InVar] -> (SimpleOptEnv, [OutVar])+subst_opt_bndrs env bndrs = mapAccumL subst_opt_bndr env bndrs++subst_opt_bndr :: SimpleOptEnv -> InVar -> (SimpleOptEnv, OutVar)+subst_opt_bndr env bndr+  | isTyVar bndr  = (env { soe_subst = subst_tv }, tv')+  | isCoVar bndr  = (env { soe_subst = subst_cv }, cv')+  | otherwise     = subst_opt_id_bndr env bndr+  where+    subst           = soe_subst env+    (subst_tv, tv') = substTyVarBndr subst bndr+    (subst_cv, cv') = substCoVarBndr subst bndr++subst_opt_id_bndr :: SimpleOptEnv -> InId -> (SimpleOptEnv, OutId)+-- Nuke all fragile IdInfo, unfolding, and RULES; it gets added back later by+-- add_info.+--+-- Rather like SimplEnv.substIdBndr+--+-- It's important to zap fragile OccInfo (which GHC.Core.Subst.substIdBndr+-- carefully does not do) because simplOptExpr invalidates it++subst_opt_id_bndr env@(SOE { soe_subst = subst, soe_inl = inl }) old_id+  = (env { soe_subst = new_subst, soe_inl = new_inl }, new_id)+  where+    Subst in_scope id_subst tv_subst cv_subst = subst++    id1    = uniqAway in_scope old_id+    id2    = setIdType id1 (substTy subst (idType old_id))+    new_id = zapFragileIdInfo id2+             -- 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++    no_change = new_id == old_id++        -- Extend the substitution if the unique has changed,+        -- See the notes with substTyVarBndr for the delSubstEnv+    new_id_subst+      | no_change = delVarEnv id_subst old_id+      | otherwise = extendVarEnv id_subst old_id (Var new_id)++    new_subst = Subst new_in_scope new_id_subst tv_subst cv_subst+    new_inl   = delVarEnv inl old_id++----------------------+add_info :: SimpleOptEnv -> InVar -> TopLevelFlag -> OutExpr -> OutVar -> OutVar+add_info env old_bndr top_level new_rhs new_bndr+ | isTyVar old_bndr = new_bndr+ | otherwise        = lazySetIdInfo new_bndr new_info+ where+   subst    = soe_subst env+   dflags   = soe_dflags env+   old_info = idInfo old_bndr++   -- Add back in the rules and unfolding which were+   -- removed by zapFragileIdInfo in subst_opt_id_bndr.+   --+   -- See Note [The Let-Unfoldings Invariant]+   new_info = idInfo new_bndr `setRuleInfo`      new_rules+                              `setUnfoldingInfo` new_unfolding++   old_rules = ruleInfo old_info+   new_rules = substSpec subst new_bndr old_rules++   old_unfolding = unfoldingInfo old_info+   new_unfolding | isStableUnfolding old_unfolding+                 = substUnfolding subst old_unfolding+                 | otherwise+                 = unfolding_from_rhs++   unfolding_from_rhs = mkUnfolding dflags InlineRhs+                                    (isTopLevel top_level)+                                    False -- may be bottom or not+                                    new_rhs++simpleUnfoldingFun :: IdUnfoldingFun+simpleUnfoldingFun id+  | isAlwaysActive (idInlineActivation id) = idUnfolding id+  | otherwise                              = noUnfolding++wrapLet :: Maybe (Id,CoreExpr) -> CoreExpr -> CoreExpr+wrapLet Nothing      body = body+wrapLet (Just (b,r)) body = Let (NonRec b r) body++{-+Note [Inline prag in simplOpt]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If there's an INLINE/NOINLINE pragma that restricts the phase in+which the binder can be inlined, we don't inline here; after all,+we don't know what phase we're in.  Here's an example++  foo :: Int -> Int -> Int+  {-# INLINE foo #-}+  foo m n = inner m+     where+       {-# INLINE [1] inner #-}+       inner m = m+n++  bar :: Int -> Int+  bar n = foo n 1++When inlining 'foo' in 'bar' we want the let-binding for 'inner'+to remain visible until Phase 1++Note [Unfold compulsory unfoldings in LHSs]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When the user writes `RULES map coerce = coerce` as a rule, the rule+will only ever match if simpleOptExpr replaces coerce by its unfolding+on the LHS, because that is the core that the rule matching engine+will find. So do that for everything that has a compulsory+unfolding. Also see Note [Desugaring coerce as cast] in GHC.HsToCore.++However, we don't want to inline 'seq', which happens to also have a+compulsory unfolding, so we only do this unfolding only for things+that are always-active.  See Note [User-defined RULES for seq] in MkId.++Note [Getting the map/coerce RULE to work]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We wish to allow the "map/coerce" RULE to fire:++  {-# RULES "map/coerce" map coerce = coerce #-}++The naive core produced for this is++  forall a b (dict :: Coercible * a b).+    map @a @b (coerce @a @b @dict) = coerce @[a] @[b] @dict'++  where dict' :: Coercible [a] [b]+        dict' = ...++This matches literal uses of `map coerce` in code, but that's not what we+want. We want it to match, say, `map MkAge` (where newtype Age = MkAge Int)+too. Some of this is addressed by compulsorily unfolding coerce on the LHS,+yielding++  forall a b (dict :: Coercible * a b).+    map @a @b (\(x :: a) -> case dict of+      MkCoercible (co :: a ~R# b) -> x |> co) = ...++Getting better. But this isn't exactly what gets produced. This is because+Coercible essentially has ~R# as a superclass, and superclasses get eagerly+extracted during solving. So we get this:++  forall a b (dict :: Coercible * a b).+    case Coercible_SCSel @* @a @b dict of+      _ [Dead] -> map @a @b (\(x :: a) -> case dict of+                               MkCoercible (co :: a ~R# b) -> x |> co) = ...++Unfortunately, this still abstracts over a Coercible dictionary. We really+want it to abstract over the ~R# evidence. So, we have Desugar.unfold_coerce,+which transforms the above to (see also Note [Desugaring coerce as cast] in+Desugar)++  forall a b (co :: a ~R# b).+    let dict = MkCoercible @* @a @b co in+    case Coercible_SCSel @* @a @b dict of+      _ [Dead] -> map @a @b (\(x :: a) -> case dict of+         MkCoercible (co :: a ~R# b) -> x |> co) = let dict = ... in ...++Now, we need simpleOptExpr to fix this up. It does so by taking three+separate actions:+  1. Inline certain non-recursive bindings. The choice whether to inline+     is made in simple_bind_pair. Note the rather specific check for+     MkCoercible in there.++  2. Stripping case expressions like the Coercible_SCSel one.+     See the `Case` case of simple_opt_expr's `go` function.++  3. Look for case expressions that unpack something that was+     just packed and inline them. This is also done in simple_opt_expr's+     `go` function.++This is all a fair amount of special-purpose hackery, but it's for+a good cause. And it won't hurt other RULES and such that it comes across.+++************************************************************************+*                                                                      *+                Join points+*                                                                      *+************************************************************************+-}++-- | Returns Just (bndr,rhs) if the binding is a join point:+-- If it's a JoinId, just return it+-- If it's not yet a JoinId but is always tail-called,+--    make it into a JoinId and return it.+-- In the latter case, eta-expand the RHS if necessary, to make the+-- lambdas explicit, as is required for join points+--+-- Precondition: the InBndr has been occurrence-analysed,+--               so its OccInfo is valid+joinPointBinding_maybe :: InBndr -> InExpr -> Maybe (InBndr, InExpr)+joinPointBinding_maybe bndr rhs+  | not (isId bndr)+  = Nothing++  | isJoinId bndr+  = Just (bndr, rhs)++  | AlwaysTailCalled join_arity <- tailCallInfo (idOccInfo bndr)+  , (bndrs, body) <- etaExpandToJoinPoint join_arity rhs+  , let str_sig   = idStrictness bndr+        str_arity = count isId bndrs  -- Strictness demands are for Ids only+        join_bndr = bndr `asJoinId`        join_arity+                         `setIdStrictness` etaExpandStrictSig str_arity str_sig+  = Just (join_bndr, mkLams bndrs body)++  | otherwise+  = Nothing++joinPointBindings_maybe :: [(InBndr, InExpr)] -> Maybe [(InBndr, InExpr)]+joinPointBindings_maybe bndrs+  = mapM (uncurry joinPointBinding_maybe) bndrs+++{- Note [Strictness and join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have++   let f = \x.  if x>200 then e1 else e1++and we know that f is strict in x.  Then if we subsequently+discover that f is an arity-2 join point, we'll eta-expand it to++   let f = \x y.  if x>200 then e1 else e1++and now it's only strict if applied to two arguments.  So we should+adjust the strictness info.++A more common case is when++   f = \x. error ".."++and again its arity increases (#15517)+-}++{- *********************************************************************+*                                                                      *+         exprIsConApp_maybe+*                                                                      *+************************************************************************++Note [exprIsConApp_maybe]+~~~~~~~~~~~~~~~~~~~~~~~~~+exprIsConApp_maybe is a very important function.  There are two principal+uses:+  * case e of { .... }+  * cls_op e, where cls_op is a class operation++In both cases you want to know if e is of form (C e1..en) where C is+a data constructor.++However e might not *look* as if+++Note [exprIsConApp_maybe on literal strings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+See #9400 and #13317.++Conceptually, a string literal "abc" is just ('a':'b':'c':[]), but in Core+they are represented as unpackCString# "abc"# by GHC.Core.Make.mkStringExprFS, or+unpackCStringUtf8# when the literal contains multi-byte UTF8 characters.++For optimizations we want to be able to treat it as a list, so they can be+decomposed when used in a case-statement. exprIsConApp_maybe detects those+calls to unpackCString# and returns:++Just (':', [Char], ['a', unpackCString# "bc"]).++We need to be careful about UTF8 strings here. ""# contains a ByteString, so+we must parse it back into a FastString to split off the first character.+That way we can treat unpackCString# and unpackCStringUtf8# in the same way.++We must also be careful about+   lvl = "foo"#+   ...(unpackCString# lvl)...+to ensure that we see through the let-binding for 'lvl'.  Hence the+(exprIsLiteral_maybe .. arg) in the guard before the call to+dealWithStringLiteral.++Note [Push coercions in exprIsConApp_maybe]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In #13025 I found a case where we had+    op (df @t1 @t2)     -- op is a ClassOp+where+    df = (/\a b. K e1 e2) |> g++To get this to come out we need to simplify on the fly+   ((/\a b. K e1 e2) |> g) @t1 @t2++Hence the use of pushCoArgs.++Note [exprIsConApp_maybe on data constructors with wrappers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Problem:+- some data constructors have wrappers+- these wrappers inline late (see MkId Note [Activation for data constructor wrappers])+- but we still want case-of-known-constructor to fire early.++Example:+   data T = MkT !Int+   $WMkT n = case n of n' -> MkT n'   -- Wrapper for MkT+   foo x = case $WMkT e of MkT y -> blah++Here we want the case-of-known-constructor transformation to fire, giving+   foo x = case e of x' -> let y = x' in blah++Here's how exprIsConApp_maybe achieves this:++0.  Start with scrutinee = $WMkT e++1.  Inline $WMkT on-the-fly.  That's why data-constructor wrappers are marked+    as expandable. (See GHC.Core.Utils.isExpandableApp.) Now we have+      scrutinee = (\n. case n of n' -> MkT n') e++2.  Beta-reduce the application, generating a floated 'let'.+    See Note [beta-reduction in exprIsConApp_maybe] below.  Now we have+      scrutinee = case n of n' -> MkT n'+      with floats {Let n = e}++3.  Float the "case x of x' ->" binding out.  Now we have+      scrutinee = MkT n'+      with floats {Let n = e; case n of n' ->}++And now we have a known-constructor MkT that we can return.++Notice that both (2) and (3) require exprIsConApp_maybe to gather and return+a bunch of floats, both let and case bindings.++Note [beta-reduction in exprIsConApp_maybe]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The unfolding a definition (_e.g._ a let-bound variable or a datacon wrapper) is+typically a function. For instance, take the wrapper for MkT in Note+[exprIsConApp_maybe on data constructors with wrappers]:++    $WMkT n = case n of { n' -> T n' }++If `exprIsConApp_maybe` is trying to analyse `$MkT arg`, upon unfolding of $MkT,+it will see++   (\n -> case n of { n' -> T n' }) arg++In order to go progress, `exprIsConApp_maybe` must perform a beta-reduction.++We don't want to blindly substitute `arg` in the body of the function, because+it duplicates work. We can (and, in fact, used to) substitute `arg` in the body,+but only when `arg` is a variable (or something equally work-free).++But, because of Note [exprIsConApp_maybe on data constructors with wrappers],+'exprIsConApp_maybe' now returns floats. So, instead, we can beta-reduce+_always_:++    (\x -> body) arg++Is transformed into++   let x = arg in body++Which, effectively, means emitting a float `let x = arg` and recursively+analysing the body.++For newtypes, this strategy requires that their wrappers have compulsory unfoldings.+Suppose we have+   newtype T a b where+     MkT :: a -> T b a   -- Note args swapped++This defines a worker function MkT, a wrapper function $WMkT, and an axT:+   $WMkT :: forall a b. a -> T b a+   $WMkT = /\b a. \(x:a). MkT a b x    -- A real binding++   MkT :: forall a b. a -> T a b+   MkT = /\a b. \(x:a). x |> (ax a b)  -- A compulsory unfolding++   axiom axT :: a ~R# T a b++Now we are optimising+   case $WMkT (I# 3) |> sym axT of I# y -> ...+we clearly want to simplify this. If $WMkT did not have a compulsory+unfolding, we would end up with+   let a = I#3 in case a of I# y -> ...+because in general, we do this on-the-fly beta-reduction+   (\x. e) blah  -->  let x = blah in e+and then float the the let.  (Substitution would risk duplicating 'blah'.)++But if the case-of-known-constructor doesn't actually fire (i.e.+exprIsConApp_maybe does not return Just) then nothing happens, and nothing+will happen the next time either.++See test T16254, which checks the behavior of newtypes.+-}++data ConCont = CC [CoreExpr] Coercion+                  -- Substitution already applied++-- | Returns @Just ([b1..bp], dc, [t1..tk], [x1..xn])@ if the argument+-- expression is a *saturated* constructor application of the form @let b1 in+-- .. let bp in dc t1..tk x1 .. xn@, where t1..tk are the+-- *universally-quantified* type args of 'dc'. Floats can also be (and most+-- likely are) single-alternative case expressions. Why does+-- 'exprIsConApp_maybe' return floats? We may have to look through lets and+-- cases to detect that we are in the presence of a data constructor wrapper. In+-- this case, we need to return the lets and cases that we traversed. See Note+-- [exprIsConApp_maybe on data constructors with wrappers]. Data constructor wrappers+-- are unfolded late, but we really want to trigger case-of-known-constructor as+-- early as possible. See also Note [Activation for data constructor wrappers]+-- in MkId.+--+-- We also return the incoming InScopeSet, augmented with+-- the binders from any [FloatBind] that we return+exprIsConApp_maybe :: InScopeEnv -> CoreExpr+                   -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])+exprIsConApp_maybe (in_scope, id_unf) expr+  = go (Left in_scope) [] expr (CC [] (mkRepReflCo (exprType expr)))+  where+    go :: Either InScopeSet Subst+             -- Left in-scope  means "empty substitution"+             -- Right subst    means "apply this substitution to the CoreExpr"+             -- NB: in the call (go subst floats expr cont)+             --     the substitution applies to 'expr', but /not/ to 'floats' or 'cont'+       -> [FloatBind] -> CoreExpr -> ConCont+             -- Notice that the floats here are in reverse order+       -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])+    go subst floats (Tick t expr) cont+       | not (tickishIsCode t) = go subst floats expr cont++    go subst floats (Cast expr co1) (CC args co2)+       | Just (args', m_co1') <- pushCoArgs (subst_co subst co1) args+            -- See Note [Push coercions in exprIsConApp_maybe]+       = case m_co1' of+           MCo co1' -> go subst floats expr (CC args' (co1' `mkTransCo` co2))+           MRefl    -> go subst floats expr (CC args' co2)++    go subst floats (App fun arg) (CC args co)+       = go subst floats fun (CC (subst_expr subst arg : args) co)++    go subst floats (Lam bndr body) (CC (arg:args) co)+       | exprIsTrivial arg          -- Don't duplicate stuff!+       = go (extend subst bndr arg) floats body (CC args co)+       | otherwise+       = let (subst', bndr') = subst_bndr subst bndr+             float           = FloatLet (NonRec bndr' arg)+         in go subst' (float:floats) body (CC args co)++    go subst floats (Let (NonRec bndr rhs) expr) cont+       = let rhs'            = subst_expr subst rhs+             (subst', bndr') = subst_bndr subst bndr+             float           = FloatLet (NonRec bndr' rhs')+         in go subst' (float:floats) expr cont++    go subst floats (Case scrut b _ [(con, vars, expr)]) cont+       = let+          scrut'           = subst_expr subst scrut+          (subst', b')     = subst_bndr subst b+          (subst'', vars') = subst_bndrs subst' vars+          float            = FloatCase scrut' b' con vars'+         in+           go subst'' (float:floats) expr cont++    go (Right sub) floats (Var v) cont+       = go (Left (substInScope sub))+            floats+            (lookupIdSubst (text "exprIsConApp" <+> ppr expr) sub v)+            cont++    go (Left in_scope) floats (Var fun) cont@(CC args co)++        | Just con <- isDataConWorkId_maybe fun+        , count isValArg args == idArity fun+        = succeedWith in_scope floats $+          pushCoDataCon con args co++        -- Look through data constructor wrappers: they inline late (See Note+        -- [Activation for data constructor wrappers]) but we want to do+        -- case-of-known-constructor optimisation eagerly.+        | isDataConWrapId fun+        , let rhs = uf_tmpl (realIdUnfolding fun)+        = go (Left in_scope) floats rhs cont++        -- Look through dictionary functions; see Note [Unfolding DFuns]+        | DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = dfun_args } <- unfolding+        , bndrs `equalLength` args    -- See Note [DFun arity check]+        , let subst = mkOpenSubst in_scope (bndrs `zip` args)+        = succeedWith in_scope floats $+          pushCoDataCon con (map (substExpr (text "exprIsConApp1") subst) dfun_args) co++        -- Look through unfoldings, but only arity-zero one;+        -- if arity > 0 we are effectively inlining a function call,+        -- and that is the business of callSiteInline.+        -- In practice, without this test, most of the "hits" were+        -- CPR'd workers getting inlined back into their wrappers,+        | idArity fun == 0+        , Just rhs <- expandUnfolding_maybe unfolding+        , let in_scope' = extendInScopeSetSet in_scope (exprFreeVars rhs)+        = go (Left in_scope') floats rhs cont++        -- See Note [exprIsConApp_maybe on literal strings]+        | (fun `hasKey` unpackCStringIdKey) ||+          (fun `hasKey` unpackCStringUtf8IdKey)+        , [arg]              <- args+        , Just (LitString str) <- exprIsLiteral_maybe (in_scope, id_unf) arg+        = succeedWith in_scope floats $+          dealWithStringLiteral fun str co+        where+          unfolding = id_unf fun++    go _ _ _ _ = Nothing++    succeedWith :: InScopeSet -> [FloatBind]+                -> Maybe (DataCon, [Type], [CoreExpr])+                -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])+    succeedWith in_scope rev_floats x+      = do { (con, tys, args) <- x+           ; let floats = reverse rev_floats+           ; return (in_scope, floats, con, tys, args) }++    ----------------------------+    -- Operations on the (Either InScopeSet GHC.Core.Subst)+    -- The Left case is wildly dominant+    subst_co (Left {}) co = co+    subst_co (Right s) co = GHC.Core.Subst.substCo s co++    subst_expr (Left {}) e = e+    subst_expr (Right s) e = substExpr (text "exprIsConApp2") s e++    subst_bndr msubst bndr+      = (Right subst', bndr')+      where+        (subst', bndr') = substBndr subst bndr+        subst = case msubst of+                  Left in_scope -> mkEmptySubst in_scope+                  Right subst   -> subst++    subst_bndrs subst bs = mapAccumL subst_bndr subst bs++    extend (Left in_scope) v e = Right (extendSubst (mkEmptySubst in_scope) v e)+    extend (Right s)       v e = Right (extendSubst s v e)+++-- See Note [exprIsConApp_maybe on literal strings]+dealWithStringLiteral :: Var -> BS.ByteString -> Coercion+                      -> Maybe (DataCon, [Type], [CoreExpr])++-- This is not possible with user-supplied empty literals, GHC.Core.Make.mkStringExprFS+-- turns those into [] automatically, but just in case something else in GHC+-- generates a string literal directly.+dealWithStringLiteral _   str co+  | BS.null str+  = pushCoDataCon nilDataCon [Type charTy] co++dealWithStringLiteral fun str co+  = let strFS = mkFastStringByteString str++        char = mkConApp charDataCon [mkCharLit (headFS strFS)]+        charTail = bytesFS (tailFS strFS)++        -- In singleton strings, just add [] instead of unpackCstring# ""#.+        rest = if BS.null charTail+                 then mkConApp nilDataCon [Type charTy]+                 else App (Var fun)+                          (Lit (LitString charTail))++    in pushCoDataCon consDataCon [Type charTy, char, rest] co++{-+Note [Unfolding DFuns]+~~~~~~~~~~~~~~~~~~~~~~+DFuns look like++  df :: forall a b. (Eq a, Eq b) -> Eq (a,b)+  df a b d_a d_b = MkEqD (a,b) ($c1 a b d_a d_b)+                               ($c2 a b d_a d_b)++So to split it up we just need to apply the ops $c1, $c2 etc+to the very same args as the dfun.  It takes a little more work+to compute the type arguments to the dictionary constructor.++Note [DFun arity check]+~~~~~~~~~~~~~~~~~~~~~~~+Here we check that the total number of supplied arguments (including+type args) matches what the dfun is expecting.  This may be *less*+than the ordinary arity of the dfun: see Note [DFun unfoldings] in GHC.Core+-}++exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal+-- Same deal as exprIsConApp_maybe, but much simpler+-- Nevertheless we do need to look through unfoldings for+-- Integer and string literals, which are vigorously hoisted to top level+-- and not subsequently inlined+exprIsLiteral_maybe env@(_, id_unf) e+  = case e of+      Lit l     -> Just l+      Tick _ e' -> exprIsLiteral_maybe env e' -- dubious?+      Var v     | Just rhs <- expandUnfolding_maybe (id_unf v)+                -> exprIsLiteral_maybe env rhs+      _         -> Nothing++{-+Note [exprIsLambda_maybe]+~~~~~~~~~~~~~~~~~~~~~~~~~~+exprIsLambda_maybe will, given an expression `e`, try to turn it into the form+`Lam v e'` (returned as `Just (v,e')`). Besides using lambdas, it looks through+casts (using the Push rule), and it unfolds function calls if the unfolding+has a greater arity than arguments are present.++Currently, it is used in GHC.Core.Rules.match, and is required to make+"map coerce = coerce" match.+-}++exprIsLambda_maybe :: InScopeEnv -> CoreExpr+                      -> Maybe (Var, CoreExpr,[Tickish Id])+    -- See Note [exprIsLambda_maybe]++-- The simple case: It is a lambda already+exprIsLambda_maybe _ (Lam x e)+    = Just (x, e, [])++-- Still straightforward: Ticks that we can float out of the way+exprIsLambda_maybe (in_scope_set, id_unf) (Tick t e)+    | tickishFloatable t+    , Just (x, e, ts) <- exprIsLambda_maybe (in_scope_set, id_unf) e+    = Just (x, e, t:ts)++-- Also possible: A casted lambda. Push the coercion inside+exprIsLambda_maybe (in_scope_set, id_unf) (Cast casted_e co)+    | Just (x, e,ts) <- exprIsLambda_maybe (in_scope_set, id_unf) casted_e+    -- Only do value lambdas.+    -- this implies that x is not in scope in gamma (makes this code simpler)+    , not (isTyVar x) && not (isCoVar x)+    , ASSERT( not $ x `elemVarSet` tyCoVarsOfCo co) True+    , Just (x',e') <- pushCoercionIntoLambda in_scope_set x e co+    , let res = Just (x',e',ts)+    = --pprTrace "exprIsLambda_maybe:Cast" (vcat [ppr casted_e,ppr co,ppr res)])+      res++-- Another attempt: See if we find a partial unfolding+exprIsLambda_maybe (in_scope_set, id_unf) e+    | (Var f, as, ts) <- collectArgsTicks tickishFloatable e+    , idArity f > count isValArg as+    -- Make sure there is hope to get a lambda+    , Just rhs <- expandUnfolding_maybe (id_unf f)+    -- Optimize, for beta-reduction+    , let e' = simpleOptExprWith unsafeGlobalDynFlags (mkEmptySubst in_scope_set) (rhs `mkApps` as)+    -- Recurse, because of possible casts+    , Just (x', e'', ts') <- exprIsLambda_maybe (in_scope_set, id_unf) e'+    , let res = Just (x', e'', ts++ts')+    = -- pprTrace "exprIsLambda_maybe:Unfold" (vcat [ppr e, ppr (x',e'')])+      res++exprIsLambda_maybe _ _e+    = -- pprTrace "exprIsLambda_maybe:Fail" (vcat [ppr _e])+      Nothing+++{- *********************************************************************+*                                                                      *+              The "push rules"+*                                                                      *+************************************************************************++Here we implement the "push rules" from FC papers:++* The push-argument rules, where we can move a coercion past an argument.+  We have+      (fun |> co) arg+  and we want to transform it to+    (fun arg') |> co'+  for some suitable co' and transformed arg'.++* The PushK rule for data constructors.  We have+       (K e1 .. en) |> co+  and we want to transform to+       (K e1' .. en')+  by pushing the coercion into the arguments+-}++pushCoArgs :: CoercionR -> [CoreArg] -> Maybe ([CoreArg], MCoercion)+pushCoArgs co []         = return ([], MCo co)+pushCoArgs co (arg:args) = do { (arg',  m_co1) <- pushCoArg  co  arg+                              ; case m_co1 of+                                  MCo co1 -> do { (args', m_co2) <- pushCoArgs co1 args+                                                 ; return (arg':args', m_co2) }+                                  MRefl  -> return (arg':args, MRefl) }++pushCoArg :: CoercionR -> CoreArg -> Maybe (CoreArg, MCoercion)+-- We have (fun |> co) arg, and we want to transform it to+--         (fun arg) |> co+-- This may fail, e.g. if (fun :: N) where N is a newtype+-- C.f. simplCast in Simplify.hs+-- 'co' is always Representational+-- If the returned coercion is Nothing, then it would have been reflexive+pushCoArg co (Type ty) = do { (ty', m_co') <- pushCoTyArg co ty+                            ; return (Type ty', m_co') }+pushCoArg co val_arg   = do { (arg_co, m_co') <- pushCoValArg co+                            ; return (val_arg `mkCast` arg_co, m_co') }++pushCoTyArg :: CoercionR -> Type -> Maybe (Type, MCoercionR)+-- We have (fun |> co) @ty+-- Push the coercion through to return+--         (fun @ty') |> co'+-- 'co' is always Representational+-- If the returned coercion is Nothing, then it would have been reflexive;+-- it's faster not to compute it, though.+pushCoTyArg co ty+  -- The following is inefficient - don't do `eqType` here, the coercion+  -- optimizer will take care of it. See #14737.+  -- -- | tyL `eqType` tyR+  -- -- = Just (ty, Nothing)++  | isReflCo co+  = Just (ty, MRefl)++  | isForAllTy_ty tyL+  = ASSERT2( isForAllTy_ty tyR, ppr co $$ ppr ty )+    Just (ty `mkCastTy` co1, MCo co2)++  | otherwise+  = Nothing+  where+    tyL = coercionLKind co+    tyR = coercionRKind co+       -- co :: tyL ~ tyR+       -- tyL = forall (a1 :: k1). ty1+       -- tyR = forall (a2 :: k2). ty2++    co1 = mkSymCo (mkNthCo Nominal 0 co)+       -- co1 :: k2 ~N k1+       -- Note that NthCo can extract a Nominal equality between the+       -- kinds of the types related by a coercion between forall-types.+       -- See the NthCo case in GHC.Core.Lint.++    co2 = mkInstCo co (mkGReflLeftCo Nominal ty co1)+        -- co2 :: ty1[ (ty|>co1)/a1 ] ~ ty2[ ty/a2 ]+        -- Arg of mkInstCo is always nominal, hence mkNomReflCo++pushCoValArg :: CoercionR -> Maybe (Coercion, MCoercion)+-- We have (fun |> co) arg+-- Push the coercion through to return+--         (fun (arg |> co_arg)) |> co_res+-- 'co' is always Representational+-- If the second returned Coercion is actually Nothing, then no cast is necessary;+-- the returned coercion would have been reflexive.+pushCoValArg co+  -- The following is inefficient - don't do `eqType` here, the coercion+  -- optimizer will take care of it. See #14737.+  -- -- | tyL `eqType` tyR+  -- -- = Just (mkRepReflCo arg, Nothing)++  | isReflCo co+  = Just (mkRepReflCo arg, MRefl)++  | isFunTy tyL+  , (co1, co2) <- decomposeFunCo Representational co+              -- If   co  :: (tyL1 -> tyL2) ~ (tyR1 -> tyR2)+              -- then co1 :: tyL1 ~ tyR1+              --      co2 :: tyL2 ~ tyR2+  = ASSERT2( isFunTy tyR, ppr co $$ ppr arg )+    Just (mkSymCo co1, MCo co2)++  | otherwise+  = Nothing+  where+    arg = funArgTy tyR+    Pair tyL tyR = coercionKind co++pushCoercionIntoLambda+    :: InScopeSet -> Var -> CoreExpr -> CoercionR -> Maybe (Var, CoreExpr)+-- This implements the Push rule from the paper on coercions+--    (\x. e) |> co+-- ===>+--    (\x'. e |> co')+pushCoercionIntoLambda in_scope x e co+    | ASSERT(not (isTyVar x) && not (isCoVar x)) True+    , Pair s1s2 t1t2 <- coercionKind co+    , Just (_s1,_s2) <- splitFunTy_maybe s1s2+    , Just (t1,_t2) <- splitFunTy_maybe t1t2+    = let (co1, co2) = decomposeFunCo Representational co+          -- Should we optimize the coercions here?+          -- Otherwise they might not match too well+          x' = x `setIdType` t1+          in_scope' = in_scope `extendInScopeSet` x'+          subst = extendIdSubst (mkEmptySubst in_scope')+                                x+                                (mkCast (Var x') co1)+      in Just (x', substExpr (text "pushCoercionIntoLambda") subst e `mkCast` co2)+    | otherwise+    = pprTrace "exprIsLambda_maybe: Unexpected lambda in case" (ppr (Lam x e))+      Nothing++pushCoDataCon :: DataCon -> [CoreExpr] -> Coercion+              -> Maybe (DataCon+                       , [Type]      -- Universal type args+                       , [CoreExpr]) -- All other args incl existentials+-- Implement the KPush reduction rule as described in "Down with kinds"+-- The transformation applies iff we have+--      (C e1 ... en) `cast` co+-- where co :: (T t1 .. tn) ~ to_ty+-- The left-hand one must be a T, because exprIsConApp returned True+-- but the right-hand one might not be.  (Though it usually will.)+pushCoDataCon dc dc_args co+  | isReflCo co || from_ty `eqType` to_ty  -- try cheap test first+  , let (univ_ty_args, rest_args) = splitAtList (dataConUnivTyVars dc) dc_args+  = Just (dc, map exprToType univ_ty_args, rest_args)++  | Just (to_tc, to_tc_arg_tys) <- splitTyConApp_maybe to_ty+  , to_tc == dataConTyCon dc+        -- These two tests can fail; we might see+        --      (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's nothing wrong with it++  = let+        tc_arity       = tyConArity to_tc+        dc_univ_tyvars = dataConUnivTyVars dc+        dc_ex_tcvars   = dataConExTyCoVars dc+        arg_tys        = dataConRepArgTys dc++        non_univ_args  = dropList dc_univ_tyvars dc_args+        (ex_args, val_args) = splitAtList dc_ex_tcvars non_univ_args++        -- Make the "Psi" from the paper+        omegas = decomposeCo tc_arity co (tyConRolesRepresentational to_tc)+        (psi_subst, to_ex_arg_tys)+          = liftCoSubstWithEx Representational+                              dc_univ_tyvars+                              omegas+                              dc_ex_tcvars+                              (map exprToType ex_args)++          -- Cast the value arguments (which include dictionaries)+        new_val_args = zipWith cast_arg arg_tys val_args+        cast_arg arg_ty arg = mkCast arg (psi_subst arg_ty)++        to_ex_args = map Type to_ex_arg_tys++        dump_doc = vcat [ppr dc,      ppr dc_univ_tyvars, ppr dc_ex_tcvars,+                         ppr arg_tys, ppr dc_args,+                         ppr ex_args, ppr val_args, ppr co, ppr from_ty, ppr to_ty, ppr to_tc ]+    in+    ASSERT2( eqType from_ty (mkTyConApp to_tc (map exprToType $ takeList dc_univ_tyvars dc_args)), dump_doc )+    ASSERT2( equalLength val_args arg_tys, dump_doc )+    Just (dc, to_tc_arg_tys, to_ex_args ++ new_val_args)++  | otherwise+  = Nothing++  where+    Pair from_ty to_ty = coercionKind co++collectBindersPushingCo :: CoreExpr -> ([Var], CoreExpr)+-- Collect lambda binders, pushing coercions inside if possible+-- E.g.   (\x.e) |> g         g :: <Int> -> blah+--        = (\x. e |> Nth 1 g)+--+-- That is,+--+-- collectBindersPushingCo ((\x.e) |> g) === ([x], e |> Nth 1 g)+collectBindersPushingCo e+  = go [] e+  where+    -- Peel off lambdas until we hit a cast.+    go :: [Var] -> CoreExpr -> ([Var], CoreExpr)+    -- The accumulator is in reverse order+    go bs (Lam b e)   = go (b:bs) e+    go bs (Cast e co) = go_c bs e co+    go bs e           = (reverse bs, e)++    -- We are in a cast; peel off casts until we hit a lambda.+    go_c :: [Var] -> CoreExpr -> CoercionR -> ([Var], CoreExpr)+    -- (go_c bs e c) is same as (go bs e (e |> c))+    go_c bs (Cast e co1) co2 = go_c bs e (co1 `mkTransCo` co2)+    go_c bs (Lam b e)    co  = go_lam bs b e co+    go_c bs e            co  = (reverse bs, mkCast e co)++    -- We are in a lambda under a cast; peel off lambdas and build a+    -- new coercion for the body.+    go_lam :: [Var] -> Var -> CoreExpr -> CoercionR -> ([Var], CoreExpr)+    -- (go_lam bs b e c) is same as (go_c bs (\b.e) c)+    go_lam bs b e co+      | isTyVar b+      , let Pair tyL tyR = coercionKind co+      , ASSERT( isForAllTy_ty tyL )+        isForAllTy_ty tyR+      , isReflCo (mkNthCo Nominal 0 co)  -- See Note [collectBindersPushingCo]+      = go_c (b:bs) e (mkInstCo co (mkNomReflCo (mkTyVarTy b)))++      | isCoVar b+      , let Pair tyL tyR = coercionKind co+      , ASSERT( isForAllTy_co tyL )+        isForAllTy_co tyR+      , isReflCo (mkNthCo Nominal 0 co)  -- See Note [collectBindersPushingCo]+      , let cov = mkCoVarCo b+      = go_c (b:bs) e (mkInstCo co (mkNomReflCo (mkCoercionTy cov)))++      | isId b+      , let Pair tyL tyR = coercionKind co+      , ASSERT( isFunTy tyL) isFunTy tyR+      , (co_arg, co_res) <- decomposeFunCo Representational co+      , isReflCo co_arg  -- See Note [collectBindersPushingCo]+      = go_c (b:bs) e co_res++      | otherwise = (reverse bs, mkCast (Lam b e) co)++{-++Note [collectBindersPushingCo]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We just look for coercions of form+   <type> -> blah+(and similarly for foralls) to keep this function simple.  We could do+more elaborate stuff, but it'd involve substitution etc.++-}

+ compiler/GHC/Core/Stats.hs view

@@ -0,0 +1,137 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-2015+-}++-- | Functions to computing the statistics reflective of the "size"+-- of a Core expression+module GHC.Core.Stats (+        -- * Expression and bindings size+        coreBindsSize, exprSize,+        CoreStats(..), coreBindsStats, exprStats,+    ) where++import GhcPrelude++import BasicTypes+import GHC.Core+import Outputable+import Coercion+import Var+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+++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,+                  text "types:"     <+> intWithCommas i2 <> comma,+                  text "coercions:" <+> intWithCommas i3 <> comma,+                  text "joins:"     <+> intWithCommas i5 <> char '/' <>+                                        intWithCommas (i4 + i5) ])++plusCS :: CoreStats -> CoreStats -> CoreStats+plusCS (CS { cs_tm = p1, cs_ty = q1, cs_co = r1, cs_vb = v1, cs_jb = j1 })+       (CS { cs_tm = p2, cs_ty = q2, cs_co = r2, cs_vb = v2, cs_jb = j2 })+  = CS { cs_tm = p1+p2, cs_ty = q1+q2, cs_co = r1+r2, cs_vb = v1+v2+       , cs_jb = j1+j2 }++zeroCS, oneTM :: CoreStats+zeroCS = CS { cs_tm = 0, cs_ty = 0, cs_co = 0, cs_vb = 0, cs_jb = 0 }+oneTM  = zeroCS { cs_tm = 1 }++sumCS :: (a -> CoreStats) -> [a] -> CoreStats+sumCS f = foldl' (\s a -> plusCS s (f a)) zeroCS++coreBindsStats :: [CoreBind] -> CoreStats+coreBindsStats = sumCS (bindStats TopLevel)++bindStats :: TopLevelFlag -> CoreBind -> CoreStats+bindStats top_lvl (NonRec v r) = bindingStats top_lvl v r+bindStats top_lvl (Rec prs)    = sumCS (\(v,r) -> bindingStats top_lvl v r) prs++bindingStats :: TopLevelFlag -> Var -> CoreExpr -> CoreStats+bindingStats top_lvl v r = letBndrStats top_lvl v `plusCS` exprStats r++bndrStats :: Var -> CoreStats+bndrStats v = oneTM `plusCS` tyStats (varType v)++letBndrStats :: TopLevelFlag -> Var -> CoreStats+letBndrStats top_lvl v+  | isTyVar v || isTopLevel top_lvl = bndrStats v+  | isJoinId v = oneTM { cs_jb = 1 } `plusCS` ty_stats+  | otherwise  = oneTM { cs_vb = 1 } `plusCS` ty_stats+  where+    ty_stats = tyStats (varType v)++exprStats :: CoreExpr -> CoreStats+exprStats (Var {})        = oneTM+exprStats (Lit {})        = oneTM+exprStats (Type t)        = tyStats t+exprStats (Coercion c)    = coStats c+exprStats (App f a)       = exprStats f `plusCS` exprStats a+exprStats (Lam b e)       = bndrStats b `plusCS` exprStats e+exprStats (Let b e)       = bindStats NotTopLevel b `plusCS` exprStats e+exprStats (Case e b _ as) = exprStats e `plusCS` bndrStats b+                                        `plusCS` sumCS altStats as+exprStats (Cast e co)     = coStats co `plusCS` exprStats e+exprStats (Tick _ e)      = exprStats e++altStats :: CoreAlt -> CoreStats+altStats (_, bs, r) = altBndrStats bs `plusCS` exprStats r++altBndrStats :: [Var] -> CoreStats+-- Charge one for the alternative, not for each binder+altBndrStats vs = oneTM `plusCS` sumCS (tyStats . varType) vs++tyStats :: Type -> CoreStats+tyStats ty = zeroCS { cs_ty = typeSize ty }++coStats :: Coercion -> CoreStats+coStats co = zeroCS { cs_co = coercionSize co }++coreBindsSize :: [CoreBind] -> Int+-- We use coreBindStats for user printout+-- but this one is a quick and dirty basis for+-- the simplifier's tick limit+coreBindsSize bs = sum (map bindSize bs)++exprSize :: CoreExpr -> Int+-- ^ A measure of the size of the expressions, strictly greater than 0+-- Counts *leaves*, not internal nodes. Types and coercions are not counted.+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 _ 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 _)        = 1+exprSize (Coercion _)    = 1++tickSize :: Tickish Id -> Int+tickSize (ProfNote _ _ _) = 1+tickSize _ = 1++bndrSize :: Var -> Int+bndrSize _ = 1++bndrsSize :: [Var] -> Int+bndrsSize = sum . map bndrSize++bindSize :: CoreBind -> Int+bindSize (NonRec b e) = bndrSize b + exprSize e+bindSize (Rec prs)    = sum (map pairSize prs)++pairSize :: (Var, CoreExpr) -> Int+pairSize (b,e) = bndrSize b + exprSize e++altSize :: CoreAlt -> Int+altSize (_,bs,e) = bndrsSize bs + exprSize e

+ compiler/GHC/Core/Subst.hs view

@@ -0,0 +1,758 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+++Utility functions on @Core@ syntax+-}++{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}+module GHC.Core.Subst (+        -- * Main data types+        Subst(..), -- Implementation exported for supercompiler's Renaming.hs only+        TvSubstEnv, IdSubstEnv, InScopeSet,++        -- ** Substituting into expressions and related types+        deShadowBinds, substSpec, substRulesForImportedIds,+        substTy, substCo, substExpr, substExprSC, substBind, substBindSC,+        substUnfolding, substUnfoldingSC,+        lookupIdSubst, lookupTCvSubst, substIdOcc,+        substTickish, substDVarSet, substIdInfo,++        -- ** Operations on substitutions+        emptySubst, mkEmptySubst, mkSubst, mkOpenSubst, substInScope, isEmptySubst,+        extendIdSubst, extendIdSubstList, extendTCvSubst, extendTvSubstList,+        extendSubst, extendSubstList, extendSubstWithVar, zapSubstEnv,+        addInScopeSet, extendInScope, extendInScopeList, extendInScopeIds,+        isInScope, setInScope, getTCvSubst, extendTvSubst, extendCvSubst,+        delBndr, delBndrs,++        -- ** Substituting and cloning binders+        substBndr, substBndrs, substRecBndrs, substTyVarBndr, substCoVarBndr,+        cloneBndr, cloneBndrs, cloneIdBndr, cloneIdBndrs, cloneRecIdBndrs,++    ) where++#include "HsVersions.h"+++import GhcPrelude++import GHC.Core+import GHC.Core.FVs+import GHC.Core.Seq+import GHC.Core.Utils+import qualified Type+import qualified Coercion++        -- We are defining local versions+import Type     hiding ( substTy, extendTvSubst, extendCvSubst, extendTvSubstList+                       , isInScope, substTyVarBndr, cloneTyVarBndr )+import Coercion hiding ( substCo, substCoVarBndr )++import PrelNames+import VarSet+import VarEnv+import Id+import Name     ( Name )+import Var+import IdInfo+import UniqSupply+import Maybes+import Util+import Outputable+import Data.List++++{-+************************************************************************+*                                                                      *+\subsection{Substitutions}+*                                                                      *+************************************************************************+-}++-- | A substitution environment, containing 'Id', 'TyVar', and 'CoVar'+-- substitutions.+--+-- Some invariants apply to how you use the substitution:+--+-- 1. Note [The substitution invariant] in TyCoSubst+--+-- 2. Note [Substitutions apply only once] in TyCoSubst+data Subst+  = Subst InScopeSet  -- Variables in in scope (both Ids and TyVars) /after/+                      -- applying the substitution+          IdSubstEnv  -- Substitution from NcIds to CoreExprs+          TvSubstEnv  -- Substitution from TyVars to Types+          CvSubstEnv  -- Substitution from CoVars to Coercions++        -- INVARIANT 1: See TyCoSubst Note [The substitution invariant]+        -- This is what lets us deal with name capture properly+        -- It's a hard invariant to check...+        --+        -- INVARIANT 2: The substitution is apply-once; see Note [Apply once] with+        --              Types.TvSubstEnv+        --+        -- INVARIANT 3: See Note [Extending the Subst]++{-+Note [Extending the Subst]+~~~~~~~~~~~~~~~~~~~~~~~~~~+For a core Subst, which binds Ids as well, we make a different choice for Ids+than we do for TyVars.++For TyVars, see Note [Extending the TCvSubst] in TyCoSubst.++For Ids, we have a different invariant+        The IdSubstEnv is extended *only* when the Unique on an Id changes+        Otherwise, we just extend the InScopeSet++In consequence:++* If all subst envs are empty, substExpr would be a+  no-op, so substExprSC ("short cut") does nothing.++  However, substExpr still goes ahead and substitutes.  Reason: we may+  want to replace existing Ids with new ones from the in-scope set, to+  avoid space leaks.++* In substIdBndr, we extend the IdSubstEnv only when the unique changes++* If the CvSubstEnv, TvSubstEnv and IdSubstEnv are all empty,+  substExpr does nothing (Note that the above rule for substIdBndr+  maintains this property.  If the incoming envts are both empty, then+  substituting the type and IdInfo can't change anything.)++* In lookupIdSubst, we *must* look up the Id in the in-scope set, because+  it may contain non-trivial changes.  Example:+        (/\a. \x:a. ...x...) Int+  We extend the TvSubstEnv with [a |-> Int]; but x's unique does not change+  so we only extend the in-scope set.  Then we must look up in the in-scope+  set when we find the occurrence of x.++* The requirement to look up the Id in the in-scope set means that we+  must NOT take no-op short cut when the IdSubst is empty.+  We must still look up every Id in the in-scope set.++* (However, we don't need to do so for expressions found in the IdSubst+  itself, whose range is assumed to be correct wrt the in-scope set.)++Why do we make a different choice for the IdSubstEnv than the+TvSubstEnv and CvSubstEnv?++* For Ids, we change the IdInfo all the time (e.g. deleting the+  unfolding), and adding it back later, so using the TyVar convention+  would entail extending the substitution almost all the time++* The simplifier wants to look up in the in-scope set anyway, in case it+  can see a better unfolding from an enclosing case expression++* For TyVars, only coercion variables can possibly change, and they are+  easy to spot+-}++-- | An environment for substituting for 'Id's+type IdSubstEnv = IdEnv CoreExpr   -- Domain is NcIds, i.e. not coercions++----------------------------+isEmptySubst :: Subst -> Bool+isEmptySubst (Subst _ id_env tv_env cv_env)+  = isEmptyVarEnv id_env && isEmptyVarEnv tv_env && isEmptyVarEnv cv_env++emptySubst :: Subst+emptySubst = Subst emptyInScopeSet emptyVarEnv emptyVarEnv emptyVarEnv++mkEmptySubst :: InScopeSet -> Subst+mkEmptySubst in_scope = Subst in_scope emptyVarEnv emptyVarEnv emptyVarEnv++mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst+mkSubst in_scope tvs cvs ids = Subst in_scope ids tvs cvs++-- | Find the in-scope set: see TyCoSubst Note [The substitution invariant]+substInScope :: Subst -> InScopeSet+substInScope (Subst in_scope _ _ _) = in_scope++-- | Remove all substitutions for 'Id's and 'Var's that might have been built up+-- while preserving the in-scope set+zapSubstEnv :: Subst -> Subst+zapSubstEnv (Subst in_scope _ _ _) = Subst in_scope emptyVarEnv emptyVarEnv emptyVarEnv++-- | Add a substitution for an 'Id' to the 'Subst': you must ensure that the in-scope set is+-- such that TyCoSubst Note [The substitution invariant]+-- holds after extending the substitution like this+extendIdSubst :: Subst -> Id -> CoreExpr -> Subst+-- ToDo: add an ASSERT that fvs(subst-result) is already in the in-scope set+extendIdSubst (Subst in_scope ids tvs cvs) v r+  = ASSERT2( isNonCoVarId v, ppr v $$ ppr r )+    Subst in_scope (extendVarEnv ids v r) tvs cvs++-- | Adds multiple 'Id' substitutions to the 'Subst': see also 'extendIdSubst'+extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst+extendIdSubstList (Subst in_scope ids tvs cvs) prs+  = ASSERT( all (isNonCoVarId . fst) prs )+    Subst in_scope (extendVarEnvList ids prs) tvs cvs++-- | Add a substitution for a 'TyVar' to the 'Subst'+-- The 'TyVar' *must* be a real TyVar, and not a CoVar+-- You must ensure that the in-scope set is such that+-- TyCoSubst Note [The substitution invariant] holds+-- after extending the substitution like this.+extendTvSubst :: Subst -> TyVar -> Type -> Subst+extendTvSubst (Subst in_scope ids tvs cvs) tv ty+  = ASSERT( isTyVar tv )+    Subst in_scope ids (extendVarEnv tvs tv ty) cvs++-- | Adds multiple 'TyVar' substitutions to the 'Subst': see also 'extendTvSubst'+extendTvSubstList :: Subst -> [(TyVar,Type)] -> Subst+extendTvSubstList subst vrs+  = foldl' extend subst vrs+  where+    extend subst (v, r) = extendTvSubst subst v r++-- | Add a substitution from a 'CoVar' to a 'Coercion' to the 'Subst':+-- you must ensure that the in-scope set satisfies+-- TyCoSubst Note [The substitution invariant]+-- after extending the substitution like this+extendCvSubst :: Subst -> CoVar -> Coercion -> Subst+extendCvSubst (Subst in_scope ids tvs cvs) v r+  = ASSERT( isCoVar v )+    Subst in_scope ids tvs (extendVarEnv cvs v r)++-- | Add a substitution appropriate to the thing being substituted+--   (whether an expression, type, or coercion). See also+--   'extendIdSubst', 'extendTvSubst', 'extendCvSubst'+extendSubst :: Subst -> Var -> CoreArg -> Subst+extendSubst subst var arg+  = case arg of+      Type ty     -> ASSERT( isTyVar var ) extendTvSubst subst var ty+      Coercion co -> ASSERT( isCoVar var ) extendCvSubst subst var co+      _           -> ASSERT( isId    var ) extendIdSubst subst var arg++extendSubstWithVar :: Subst -> Var -> Var -> Subst+extendSubstWithVar subst v1 v2+  | isTyVar v1 = ASSERT( isTyVar v2 ) extendTvSubst subst v1 (mkTyVarTy v2)+  | isCoVar v1 = ASSERT( isCoVar v2 ) extendCvSubst subst v1 (mkCoVarCo v2)+  | otherwise  = ASSERT( isId    v2 ) extendIdSubst subst v1 (Var v2)++-- | Add a substitution as appropriate to each of the terms being+--   substituted (whether expressions, types, or coercions). See also+--   'extendSubst'.+extendSubstList :: Subst -> [(Var,CoreArg)] -> Subst+extendSubstList subst []              = subst+extendSubstList subst ((var,rhs):prs) = extendSubstList (extendSubst subst var rhs) prs++-- | Find the substitution for an 'Id' in the 'Subst'+lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr+lookupIdSubst doc (Subst in_scope ids _ _) v+  | not (isLocalId v) = Var v+  | Just e  <- lookupVarEnv ids       v = e+  | Just v' <- lookupInScope in_scope v = Var v'+        -- Vital! See Note [Extending the Subst]+  | otherwise = WARN( True, text "GHC.Core.Subst.lookupIdSubst" <+> doc <+> ppr v+                            $$ ppr in_scope)+                Var v++-- | Find the substitution for a 'TyVar' in the 'Subst'+lookupTCvSubst :: Subst -> TyVar -> Type+lookupTCvSubst (Subst _ _ tvs cvs) v+  | isTyVar v+  = lookupVarEnv tvs v `orElse` Type.mkTyVarTy v+  | otherwise+  = mkCoercionTy $ lookupVarEnv cvs v `orElse` mkCoVarCo v++delBndr :: Subst -> Var -> Subst+delBndr (Subst in_scope ids tvs cvs) v+  | isCoVar v = Subst in_scope ids tvs (delVarEnv cvs v)+  | isTyVar v = Subst in_scope ids (delVarEnv tvs v) cvs+  | otherwise = Subst in_scope (delVarEnv ids v) tvs cvs++delBndrs :: Subst -> [Var] -> Subst+delBndrs (Subst in_scope ids tvs cvs) vs+  = Subst in_scope (delVarEnvList ids vs) (delVarEnvList tvs vs) (delVarEnvList cvs vs)+      -- Easiest thing is just delete all from all!++-- | Simultaneously substitute for a bunch of variables+--   No left-right shadowing+--   ie the substitution for   (\x \y. e) a1 a2+--      so neither x nor y scope over a1 a2+mkOpenSubst :: InScopeSet -> [(Var,CoreArg)] -> Subst+mkOpenSubst in_scope pairs = Subst in_scope+                                   (mkVarEnv [(id,e)  | (id, e) <- pairs, isId id])+                                   (mkVarEnv [(tv,ty) | (tv, Type ty) <- pairs])+                                   (mkVarEnv [(v,co)  | (v, Coercion co) <- pairs])++------------------------------+isInScope :: Var -> Subst -> Bool+isInScope v (Subst in_scope _ _ _) = v `elemInScopeSet` in_scope++-- | Add the 'Var' to the in-scope set, but do not remove+-- any existing substitutions for it+addInScopeSet :: Subst -> VarSet -> Subst+addInScopeSet (Subst in_scope ids tvs cvs) vs+  = Subst (in_scope `extendInScopeSetSet` vs) ids tvs cvs++-- | Add the 'Var' to the in-scope set: as a side effect,+-- and remove any existing substitutions for it+extendInScope :: Subst -> Var -> Subst+extendInScope (Subst in_scope ids tvs cvs) v+  = Subst (in_scope `extendInScopeSet` v)+          (ids `delVarEnv` v) (tvs `delVarEnv` v) (cvs `delVarEnv` v)++-- | Add the 'Var's to the in-scope set: see also 'extendInScope'+extendInScopeList :: Subst -> [Var] -> Subst+extendInScopeList (Subst in_scope ids tvs cvs) vs+  = Subst (in_scope `extendInScopeSetList` vs)+          (ids `delVarEnvList` vs) (tvs `delVarEnvList` vs) (cvs `delVarEnvList` vs)++-- | Optimized version of 'extendInScopeList' that can be used if you are certain+-- all the things being added are 'Id's and hence none are 'TyVar's or 'CoVar's+extendInScopeIds :: Subst -> [Id] -> Subst+extendInScopeIds (Subst in_scope ids tvs cvs) vs+  = Subst (in_scope `extendInScopeSetList` vs)+          (ids `delVarEnvList` vs) tvs cvs++setInScope :: Subst -> InScopeSet -> Subst+setInScope (Subst _ ids tvs cvs) in_scope = Subst in_scope ids tvs cvs++-- Pretty printing, for debugging only++instance Outputable Subst where+  ppr (Subst in_scope ids tvs cvs)+        =  text "<InScope =" <+> in_scope_doc+        $$ text " IdSubst   =" <+> ppr ids+        $$ text " TvSubst   =" <+> ppr tvs+        $$ text " CvSubst   =" <+> ppr cvs+         <> char '>'+    where+    in_scope_doc = pprVarSet (getInScopeVars in_scope) (braces . fsep . map ppr)++{-+************************************************************************+*                                                                      *+        Substituting expressions+*                                                                      *+************************************************************************+-}++-- | Apply a substitution to an entire 'CoreExpr'. Remember, you may only+-- apply the substitution /once/:+-- See Note [Substitutions apply only once] in TyCoSubst+--+-- Do *not* attempt to short-cut in the case of an empty substitution!+-- See Note [Extending the Subst]+substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr+substExprSC doc subst orig_expr+  | isEmptySubst subst = orig_expr+  | otherwise          = -- pprTrace "enter subst-expr" (doc $$ ppr orig_expr) $+                         subst_expr doc subst orig_expr++substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr+substExpr doc subst orig_expr = subst_expr doc subst orig_expr++subst_expr :: SDoc -> Subst -> CoreExpr -> CoreExpr+subst_expr doc subst expr+  = go expr+  where+    go (Var v)         = lookupIdSubst (doc $$ text "subst_expr") subst v+    go (Type ty)       = Type (substTy subst ty)+    go (Coercion co)   = Coercion (substCo subst co)+    go (Lit lit)       = Lit lit+    go (App fun arg)   = App (go fun) (go arg)+    go (Tick tickish e) = mkTick (substTickish subst tickish) (go e)+    go (Cast e co)     = Cast (go e) (substCo subst co)+       -- Do not optimise even identity coercions+       -- Reason: substitution applies to the LHS of RULES, and+       --         if you "optimise" an identity coercion, you may+       --         lose a binder. We optimise the LHS of rules at+       --         construction time++    go (Lam bndr body) = Lam bndr' (subst_expr doc subst' body)+                       where+                         (subst', bndr') = substBndr subst bndr++    go (Let bind body) = Let bind' (subst_expr doc subst' body)+                       where+                         (subst', bind') = substBind subst bind++    go (Case scrut bndr ty alts) = Case (go scrut) bndr' (substTy subst ty) (map (go_alt subst') alts)+                                 where+                                 (subst', bndr') = substBndr subst bndr++    go_alt subst (con, bndrs, rhs) = (con, bndrs', subst_expr doc subst' rhs)+                                 where+                                   (subst', bndrs') = substBndrs subst bndrs++-- | Apply a substitution to an entire 'CoreBind', additionally returning an updated 'Subst'+-- that should be used by subsequent substitutions.+substBind, substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)++substBindSC subst bind    -- Short-cut if the substitution is empty+  | not (isEmptySubst subst)+  = substBind subst bind+  | otherwise+  = case bind of+       NonRec bndr rhs -> (subst', NonRec bndr' rhs)+          where+            (subst', bndr') = substBndr subst bndr+       Rec pairs -> (subst', Rec (bndrs' `zip` rhss'))+          where+            (bndrs, rhss)    = unzip pairs+            (subst', bndrs') = substRecBndrs subst bndrs+            rhss' | isEmptySubst subst'+                  = rhss+                  | otherwise+                  = map (subst_expr (text "substBindSC") subst') rhss++substBind subst (NonRec bndr rhs)+  = (subst', NonRec bndr' (subst_expr (text "substBind") subst rhs))+  where+    (subst', bndr') = substBndr subst bndr++substBind subst (Rec pairs)+   = (subst', Rec (bndrs' `zip` rhss'))+   where+       (bndrs, rhss)    = unzip pairs+       (subst', bndrs') = substRecBndrs subst bndrs+       rhss' = map (subst_expr (text "substBind") subst') rhss++-- | De-shadowing the program is sometimes a useful pre-pass. It can be done simply+-- by running over the bindings with an empty substitution, because substitution+-- returns a result that has no-shadowing guaranteed.+--+-- (Actually, within a single /type/ there might still be shadowing, because+-- 'substTy' is a no-op for the empty substitution, but that's probably OK.)+--+-- [Aug 09] This function is not used in GHC at the moment, but seems so+--          short and simple that I'm going to leave it here+deShadowBinds :: CoreProgram -> CoreProgram+deShadowBinds binds = snd (mapAccumL substBind emptySubst binds)++{-+************************************************************************+*                                                                      *+        Substituting binders+*                                                                      *+************************************************************************++Remember that substBndr and friends are used when doing expression+substitution only.  Their only business is substitution, so they+preserve all IdInfo (suitably substituted).  For example, we *want* to+preserve occ info in rules.+-}++-- | Substitutes a 'Var' for another one according to the 'Subst' given, returning+-- the result and an updated 'Subst' that should be used by subsequent substitutions.+-- 'IdInfo' is preserved by this process, although it is substituted into appropriately.+substBndr :: Subst -> Var -> (Subst, Var)+substBndr subst bndr+  | isTyVar bndr  = substTyVarBndr subst bndr+  | isCoVar bndr  = substCoVarBndr subst bndr+  | otherwise     = substIdBndr (text "var-bndr") subst subst bndr++-- | Applies 'substBndr' to a number of 'Var's, accumulating a new 'Subst' left-to-right+substBndrs :: Subst -> [Var] -> (Subst, [Var])+substBndrs subst bndrs = mapAccumL substBndr subst bndrs++-- | Substitute in a mutually recursive group of 'Id's+substRecBndrs :: Subst -> [Id] -> (Subst, [Id])+substRecBndrs subst bndrs+  = (new_subst, new_bndrs)+  where         -- Here's the reason we need to pass rec_subst to subst_id+    (new_subst, new_bndrs) = mapAccumL (substIdBndr (text "rec-bndr") new_subst) subst bndrs++substIdBndr :: SDoc+            -> Subst            -- ^ Substitution to use for the IdInfo+            -> Subst -> Id      -- ^ Substitution and Id to transform+            -> (Subst, Id)      -- ^ Transformed pair+                                -- NB: unfolding may be zapped++substIdBndr _doc rec_subst subst@(Subst in_scope env tvs cvs) old_id+  = -- pprTrace "substIdBndr" (doc $$ ppr old_id $$ ppr in_scope) $+    (Subst (in_scope `extendInScopeSet` new_id) new_env tvs cvs, new_id)+  where+    id1 = uniqAway in_scope old_id      -- id1 is cloned if necessary+    id2 | no_type_change = id1+        | otherwise      = setIdType id1 (substTy subst old_ty)++    old_ty = idType old_id+    no_type_change = (isEmptyVarEnv tvs && isEmptyVarEnv cvs) ||+                     noFreeVarsOfType old_ty++        -- new_id has the right IdInfo+        -- The lazy-set is because we're in a loop here, with+        -- rec_subst, when dealing with a mutually-recursive group+    new_id = maybeModifyIdInfo mb_new_info id2+    mb_new_info = substIdInfo rec_subst id2 (idInfo id2)+        -- NB: unfolding info may be zapped++        -- Extend the substitution if the unique has changed+        -- See the notes with substTyVarBndr for the delVarEnv+    new_env | no_change = delVarEnv env old_id+            | otherwise = extendVarEnv env old_id (Var new_id)++    no_change = id1 == old_id+        -- See Note [Extending the Subst]+        -- it's /not/ necessary to check mb_new_info and no_type_change++{-+Now a variant that unconditionally allocates a new unique.+It also unconditionally zaps the OccInfo.+-}++-- | Very similar to 'substBndr', but it always allocates a new 'Unique' for+-- each variable in its output.  It substitutes the IdInfo though.+cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)+cloneIdBndr subst us old_id+  = clone_id subst subst (old_id, uniqFromSupply us)++-- | Applies 'cloneIdBndr' to a number of 'Id's, accumulating a final+-- substitution from left to right+cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])+cloneIdBndrs subst us ids+  = mapAccumL (clone_id subst) subst (ids `zip` uniqsFromSupply us)++cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])+-- Works for all kinds of variables (typically case binders)+-- not just Ids+cloneBndrs subst us vs+  = mapAccumL (\subst (v, u) -> cloneBndr subst u v) subst (vs `zip` uniqsFromSupply us)++cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)+cloneBndr subst uniq v+  | isTyVar v = cloneTyVarBndr subst v uniq+  | otherwise = clone_id subst subst (v,uniq)  -- Works for coercion variables too++-- | Clone a mutually recursive group of 'Id's+cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])+cloneRecIdBndrs subst us ids+  = (subst', ids')+  where+    (subst', ids') = mapAccumL (clone_id subst') subst+                               (ids `zip` uniqsFromSupply us)++-- Just like substIdBndr, except that it always makes a new unique+-- It is given the unique to use+clone_id    :: Subst                    -- Substitution for the IdInfo+            -> Subst -> (Id, Unique)    -- Substitution and Id to transform+            -> (Subst, Id)              -- Transformed pair++clone_id rec_subst subst@(Subst in_scope idvs tvs cvs) (old_id, uniq)+  = (Subst (in_scope `extendInScopeSet` new_id) new_idvs tvs new_cvs, new_id)+  where+    id1     = setVarUnique old_id uniq+    id2     = substIdType subst id1+    new_id  = maybeModifyIdInfo (substIdInfo rec_subst id2 (idInfo old_id)) id2+    (new_idvs, new_cvs) | isCoVar old_id = (idvs, extendVarEnv cvs old_id (mkCoVarCo new_id))+                        | otherwise      = (extendVarEnv idvs old_id (Var new_id), cvs)++{-+************************************************************************+*                                                                      *+                Types and Coercions+*                                                                      *+************************************************************************++For types and coercions we just call the corresponding functions in+Type and Coercion, but we have to repackage the substitution, from a+Subst to a TCvSubst.+-}++substTyVarBndr :: Subst -> TyVar -> (Subst, TyVar)+substTyVarBndr (Subst in_scope id_env tv_env cv_env) tv+  = case Type.substTyVarBndr (TCvSubst in_scope tv_env cv_env) tv of+        (TCvSubst in_scope' tv_env' cv_env', tv')+           -> (Subst in_scope' id_env tv_env' cv_env', tv')++cloneTyVarBndr :: Subst -> TyVar -> Unique -> (Subst, TyVar)+cloneTyVarBndr (Subst in_scope id_env tv_env cv_env) tv uniq+  = case Type.cloneTyVarBndr (TCvSubst in_scope tv_env cv_env) tv uniq of+        (TCvSubst in_scope' tv_env' cv_env', tv')+           -> (Subst in_scope' id_env tv_env' cv_env', tv')++substCoVarBndr :: Subst -> TyVar -> (Subst, TyVar)+substCoVarBndr (Subst in_scope id_env tv_env cv_env) cv+  = case Coercion.substCoVarBndr (TCvSubst in_scope tv_env cv_env) cv of+        (TCvSubst in_scope' tv_env' cv_env', cv')+           -> (Subst in_scope' id_env tv_env' cv_env', cv')++-- | See 'Type.substTy'+substTy :: Subst -> Type -> Type+substTy subst ty = Type.substTyUnchecked (getTCvSubst subst) ty++getTCvSubst :: Subst -> TCvSubst+getTCvSubst (Subst in_scope _ tenv cenv) = TCvSubst in_scope tenv cenv++-- | See 'Coercion.substCo'+substCo :: HasCallStack => Subst -> Coercion -> Coercion+substCo subst co = Coercion.substCo (getTCvSubst subst) co++{-+************************************************************************+*                                                                      *+\section{IdInfo substitution}+*                                                                      *+************************************************************************+-}++substIdType :: Subst -> Id -> Id+substIdType subst@(Subst _ _ tv_env cv_env) id+  | (isEmptyVarEnv tv_env && isEmptyVarEnv cv_env) || noFreeVarsOfType old_ty = id+  | otherwise   = setIdType id (substTy subst old_ty)+                -- The tyCoVarsOfType is cheaper than it looks+                -- because we cache the free tyvars of the type+                -- in a Note in the id's type itself+  where+    old_ty = idType id++------------------+-- | Substitute into some 'IdInfo' with regard to the supplied new 'Id'.+substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo+substIdInfo subst new_id info+  | nothing_to_do = Nothing+  | otherwise     = Just (info `setRuleInfo`      substSpec subst new_id old_rules+                               `setUnfoldingInfo` substUnfolding subst old_unf)+  where+    old_rules     = ruleInfo info+    old_unf       = unfoldingInfo info+    nothing_to_do = isEmptyRuleInfo old_rules && not (isFragileUnfolding old_unf)++------------------+-- | Substitutes for the 'Id's within an unfolding+substUnfolding, substUnfoldingSC :: Subst -> Unfolding -> Unfolding+        -- Seq'ing on the returned Unfolding is enough to cause+        -- all the substitutions to happen completely++substUnfoldingSC subst unf       -- Short-cut version+  | isEmptySubst subst = unf+  | otherwise          = substUnfolding subst unf++substUnfolding subst df@(DFunUnfolding { df_bndrs = bndrs, df_args = args })+  = df { df_bndrs = bndrs', df_args = args' }+  where+    (subst',bndrs') = substBndrs subst bndrs+    args'           = map (substExpr (text "subst-unf:dfun") subst') args++substUnfolding subst unf@(CoreUnfolding { uf_tmpl = tmpl, uf_src = src })+        -- Retain an InlineRule!+  | not (isStableSource src)  -- Zap an unstable unfolding, to save substitution work+  = NoUnfolding+  | otherwise                 -- But keep a stable one!+  = seqExpr new_tmpl `seq`+    unf { uf_tmpl = new_tmpl }+  where+    new_tmpl = substExpr (text "subst-unf") subst tmpl++substUnfolding _ unf = unf      -- NoUnfolding, OtherCon++------------------+substIdOcc :: Subst -> Id -> Id+-- These Ids should not be substituted to non-Ids+substIdOcc subst v = case lookupIdSubst (text "substIdOcc") subst v of+                        Var v' -> v'+                        other  -> pprPanic "substIdOcc" (vcat [ppr v <+> ppr other, ppr subst])++------------------+-- | Substitutes for the 'Id's within the 'WorkerInfo' given the new function 'Id'+substSpec :: Subst -> Id -> RuleInfo -> RuleInfo+substSpec subst new_id (RuleInfo rules rhs_fvs)+  = seqRuleInfo new_spec `seq` new_spec+  where+    subst_ru_fn = const (idName new_id)+    new_spec = RuleInfo (map (substRule subst subst_ru_fn) rules)+                        (substDVarSet subst rhs_fvs)++------------------+substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]+substRulesForImportedIds subst rules+  = map (substRule subst not_needed) rules+  where+    not_needed name = pprPanic "substRulesForImportedIds" (ppr name)++------------------+substRule :: Subst -> (Name -> Name) -> CoreRule -> CoreRule++-- The subst_ru_fn argument is applied to substitute the ru_fn field+-- of the rule:+--    - Rules for *imported* Ids never change ru_fn+--    - Rules for *local* Ids are in the IdInfo for that Id,+--      and the ru_fn field is simply replaced by the new name+--      of the Id+substRule _ _ rule@(BuiltinRule {}) = rule+substRule subst subst_ru_fn rule@(Rule { ru_bndrs = bndrs, ru_args = args+                                       , ru_fn = fn_name, ru_rhs = rhs+                                       , ru_local = is_local })+  = rule { ru_bndrs = bndrs'+         , ru_fn    = if is_local+                        then subst_ru_fn fn_name+                        else fn_name+         , ru_args  = map (substExpr doc subst') args+         , ru_rhs   = substExpr (text "foo") subst' rhs }+           -- Do NOT optimise the RHS (previously we did simplOptExpr here)+           -- See Note [Substitute lazily]+  where+    doc = text "subst-rule" <+> ppr fn_name+    (subst', bndrs') = substBndrs subst bndrs++------------------+substDVarSet :: Subst -> DVarSet -> DVarSet+substDVarSet subst fvs+  = mkDVarSet $ fst $ foldr (subst_fv subst) ([], emptyVarSet) $ dVarSetElems fvs+  where+  subst_fv subst fv acc+     | isId fv = expr_fvs (lookupIdSubst (text "substDVarSet") subst fv) isLocalVar emptyVarSet $! acc+     | otherwise = tyCoFVsOfType (lookupTCvSubst subst fv) (const True) emptyVarSet $! acc++------------------+substTickish :: Subst -> Tickish Id -> Tickish Id+substTickish subst (Breakpoint n ids)+   = Breakpoint n (map do_one ids)+ where+    do_one = getIdFromTrivialExpr . lookupIdSubst (text "subst_tickish") subst+substTickish _subst other = other++{- Note [Substitute lazily]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+The functions that substitute over IdInfo must be pretty lazy, because+they are knot-tied by substRecBndrs.++One case in point was #10627 in which a rule for a function 'f'+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>>.++In any case we don't need to optimise the RHS of rules, or unfoldings,+because the simplifier will do that.+++Note [substTickish]+~~~~~~~~~~~~~~~~~~~~~~+A Breakpoint contains a list of Ids.  What happens if we ever want to+substitute an expression for one of these Ids?++First, we ensure that we only ever substitute trivial expressions for+these Ids, by marking them as NoOccInfo in the occurrence analyser.+Then, when substituting for the Id, we unwrap any type applications+and abstractions to get back to an Id, with getIdFromTrivialExpr.++Second, we have to ensure that we never try to substitute a literal+for an Id in a breakpoint.  We ensure this by never storing an Id with+an unlifted type in a Breakpoint - see GHC.HsToCore.Coverage.mkTickish.+Breakpoints can't handle free variables with unlifted types anyway.+-}++{-+Note [Worker inlining]+~~~~~~~~~~~~~~~~~~~~~~+A worker can get substituted away entirely.+        - it might be trivial+        - it might simply be very small+We do not treat an InlWrapper as an 'occurrence' in the occurrence+analyser, so it's possible that the worker is not even in scope any more.++In all all these cases we simply drop the special case, returning to+InlVanilla.  The WARN is just so I can see if it happens a lot.+-}+

+ compiler/GHC/Core/Unfold.hs view

@@ -0,0 +1,1642 @@+{-+(c) The University of Glasgow 2006+(c) The AQUA Project, Glasgow University, 1994-1998+++Core-syntax unfoldings++Unfoldings (which can travel across module boundaries) are in Core+syntax (namely @CoreExpr@s).++The type @Unfolding@ sits ``above'' simply-Core-expressions+unfoldings, capturing ``higher-level'' things we know about a binding,+usually things that the simplifier found out (e.g., ``it's a+literal'').  In the corner of a @CoreUnfolding@ unfolding, you will+find, unsurprisingly, a Core expression.+-}++{-# LANGUAGE CPP #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++module GHC.Core.Unfold (+        Unfolding, UnfoldingGuidance,   -- Abstract types++        noUnfolding, mkImplicitUnfolding,+        mkUnfolding, mkCoreUnfolding,+        mkTopUnfolding, mkSimpleUnfolding, mkWorkerUnfolding,+        mkInlineUnfolding, mkInlineUnfoldingWithArity,+        mkInlinableUnfolding, mkWwInlineRule,+        mkCompulsoryUnfolding, mkDFunUnfolding,+        specUnfolding,++        ArgSummary(..),++        couldBeSmallEnoughToInline, inlineBoringOk,+        certainlyWillInline, smallEnoughToInline,++        callSiteInline, CallCtxt(..),++        -- Reexport from GHC.Core.Subst (it only live there so it can be used+        -- by the Very Simple Optimiser)+        exprIsConApp_maybe, exprIsLiteral_maybe+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Driver.Session+import GHC.Core+import OccurAnal          ( occurAnalyseExpr_NoBinderSwap )+import GHC.Core.SimpleOpt+import GHC.Core.Arity     ( manifestArity )+import GHC.Core.Utils+import Id+import Demand          ( isBottomingSig )+import DataCon+import Literal+import PrimOp+import IdInfo+import BasicTypes       ( Arity, InlineSpec(..), inlinePragmaSpec )+import Type+import PrelNames+import TysPrim          ( realWorldStatePrimTy )+import Bag+import Util+import Outputable+import ForeignCall+import Name+import ErrUtils++import qualified Data.ByteString as BS+import Data.List++{-+************************************************************************+*                                                                      *+\subsection{Making unfoldings}+*                                                                      *+************************************************************************+-}++mkTopUnfolding :: DynFlags -> Bool -> CoreExpr -> Unfolding+mkTopUnfolding dflags is_bottoming rhs+  = mkUnfolding dflags InlineRhs True is_bottoming rhs++mkImplicitUnfolding :: DynFlags -> CoreExpr -> Unfolding+-- For implicit Ids, do a tiny bit of optimising first+mkImplicitUnfolding dflags expr+  = mkTopUnfolding dflags False (simpleOptExpr dflags expr)++-- Note [Top-level flag on inline rules]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- Slight hack: note that mk_inline_rules conservatively sets the+-- top-level flag to True.  It gets set more accurately by the simplifier+-- Simplify.simplUnfolding.++mkSimpleUnfolding :: DynFlags -> CoreExpr -> Unfolding+mkSimpleUnfolding dflags rhs+  = mkUnfolding dflags InlineRhs False False rhs++mkDFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding+mkDFunUnfolding bndrs con ops+  = DFunUnfolding { df_bndrs = bndrs+                  , df_con = con+                  , df_args = map occurAnalyseExpr_NoBinderSwap ops }+                  -- See Note [Occurrence analysis of unfoldings]++mkWwInlineRule :: DynFlags -> CoreExpr -> Arity -> Unfolding+mkWwInlineRule dflags expr arity+  = mkCoreUnfolding InlineStable True+                   (simpleOptExpr dflags expr)+                   (UnfWhen { ug_arity = arity, ug_unsat_ok = unSaturatedOk+                            , ug_boring_ok = boringCxtNotOk })++mkCompulsoryUnfolding :: CoreExpr -> Unfolding+mkCompulsoryUnfolding expr         -- Used for things that absolutely must be unfolded+  = mkCoreUnfolding InlineCompulsory True+                    (simpleOptExpr unsafeGlobalDynFlags expr)+                    (UnfWhen { ug_arity = 0    -- Arity of unfolding doesn't matter+                             , ug_unsat_ok = unSaturatedOk, ug_boring_ok = boringCxtOk })++mkWorkerUnfolding :: DynFlags -> (CoreExpr -> CoreExpr) -> Unfolding -> Unfolding+-- See Note [Worker-wrapper for INLINABLE functions] in WorkWrap+mkWorkerUnfolding dflags work_fn+                  (CoreUnfolding { uf_src = src, uf_tmpl = tmpl+                                 , uf_is_top = top_lvl })+  | isStableSource src+  = mkCoreUnfolding src top_lvl new_tmpl guidance+  where+    new_tmpl = simpleOptExpr dflags (work_fn tmpl)+    guidance = calcUnfoldingGuidance dflags False new_tmpl++mkWorkerUnfolding _ _ _ = noUnfolding++-- | Make an unfolding that may be used unsaturated+-- (ug_unsat_ok = unSaturatedOk) and that is reported as having its+-- manifest arity (the number of outer lambdas applications will+-- resolve before doing any work).+mkInlineUnfolding :: CoreExpr -> Unfolding+mkInlineUnfolding expr+  = mkCoreUnfolding InlineStable+                    True         -- Note [Top-level flag on inline rules]+                    expr' guide+  where+    expr' = simpleOptExpr unsafeGlobalDynFlags expr+    guide = UnfWhen { ug_arity = manifestArity expr'+                    , ug_unsat_ok = unSaturatedOk+                    , ug_boring_ok = boring_ok }+    boring_ok = inlineBoringOk expr'++-- | Make an unfolding that will be used once the RHS has been saturated+-- to the given arity.+mkInlineUnfoldingWithArity :: Arity -> CoreExpr -> Unfolding+mkInlineUnfoldingWithArity arity expr+  = mkCoreUnfolding InlineStable+                    True         -- Note [Top-level flag on inline rules]+                    expr' guide+  where+    expr' = simpleOptExpr unsafeGlobalDynFlags expr+    guide = UnfWhen { ug_arity = arity+                    , ug_unsat_ok = needSaturated+                    , ug_boring_ok = boring_ok }+    -- See Note [INLINE pragmas and boring contexts] as to why we need to look+    -- at the arity here.+    boring_ok | arity == 0 = True+              | otherwise  = inlineBoringOk expr'++mkInlinableUnfolding :: DynFlags -> CoreExpr -> Unfolding+mkInlinableUnfolding dflags expr+  = mkUnfolding dflags InlineStable False False expr'+  where+    expr' = simpleOptExpr dflags expr++specUnfolding :: DynFlags -> [Var] -> (CoreExpr -> CoreExpr) -> Arity+              -> Unfolding -> Unfolding+-- See Note [Specialising unfoldings]+-- specUnfolding spec_bndrs spec_app arity_decrease unf+--   = \spec_bndrs. spec_app( unf )+--+specUnfolding dflags spec_bndrs spec_app arity_decrease+              df@(DFunUnfolding { df_bndrs = old_bndrs, df_con = con, df_args = args })+  = ASSERT2( arity_decrease == count isId old_bndrs - count isId spec_bndrs, ppr df )+    mkDFunUnfolding spec_bndrs con (map spec_arg args)+      -- There is a hard-to-check assumption here that the spec_app has+      -- enough applications to exactly saturate the old_bndrs+      -- For DFunUnfoldings we transform+      --       \old_bndrs. MkD <op1> ... <opn>+      -- to+      --       \new_bndrs. MkD (spec_app(\old_bndrs. <op1>)) ... ditto <opn>+      -- The ASSERT checks the value part of that+  where+    spec_arg arg = simpleOptExpr dflags (spec_app (mkLams old_bndrs arg))+                   -- The beta-redexes created by spec_app will be+                   -- simplified away by simplOptExpr++specUnfolding dflags spec_bndrs spec_app arity_decrease+              (CoreUnfolding { uf_src = src, uf_tmpl = tmpl+                             , uf_is_top = top_lvl+                             , uf_guidance = old_guidance })+ | isStableSource src  -- See Note [Specialising unfoldings]+ , UnfWhen { ug_arity     = old_arity+           , ug_unsat_ok  = unsat_ok+           , ug_boring_ok = boring_ok } <- old_guidance+ = let guidance = UnfWhen { ug_arity     = old_arity - arity_decrease+                          , ug_unsat_ok  = unsat_ok+                          , ug_boring_ok = boring_ok }+       new_tmpl = simpleOptExpr dflags (mkLams spec_bndrs (spec_app tmpl))+                   -- The beta-redexes created by spec_app will be+                   -- simplified away by simplOptExpr++   in mkCoreUnfolding src top_lvl new_tmpl guidance++specUnfolding _ _ _ _ _ = noUnfolding++{- Note [Specialising unfoldings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we specialise a function for some given type-class arguments, we use+specUnfolding to specialise its unfolding.  Some important points:++* If the original function has a DFunUnfolding, the specialised one+  must do so too!  Otherwise we lose the magic rules that make it+  interact with ClassOps++* There is a bit of hack for INLINABLE functions:+     f :: Ord a => ....+     f = <big-rhs>+     {- INLINABLE f #-}+  Now if we specialise f, should the specialised version still have+  an INLINABLE pragma?  If it does, we'll capture a specialised copy+  of <big-rhs> as its unfolding, and that probably won't inline.  But+  if we don't, the specialised version of <big-rhs> might be small+  enough to inline at a call site. This happens with Control.Monad.liftM3,+  and can cause a lot more allocation as a result (nofib n-body shows this).++  Moreover, keeping the INLINABLE thing isn't much help, because+  the specialised function (probably) isn't overloaded any more.++  Conclusion: drop the INLINEALE pragma.  In practice what this means is:+     if a stable unfolding has UnfoldingGuidance of UnfWhen,+        we keep it (so the specialised thing too will always inline)+     if a stable unfolding has UnfoldingGuidance of UnfIfGoodArgs+        (which arises from INLINABLE), we discard it++Note [Honour INLINE on 0-ary bindings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider++   x = <expensive>+   {-# INLINE x #-}++   f y = ...x...++The semantics of an INLINE pragma is++  inline x at every call site, provided it is saturated;+  that is, applied to at least as many arguments as appear+  on the LHS of the Haskell source definition.++(This source-code-derived arity is stored in the `ug_arity` field of+the `UnfoldingGuidance`.)++In the example, x's ug_arity is 0, so we should inline it at every use+site.  It's rare to have such an INLINE pragma (usually INLINE Is on+functions), but it's occasionally very important (#15578, #15519).+In #15519 we had something like+   x = case (g a b) of I# r -> T r+   {-# INLINE x #-}+   f y = ...(h x)....++where h is strict.  So we got+   f y = ...(case g a b of I# r -> h (T r))...++and that in turn allowed SpecConstr to ramp up performance.++How do we deliver on this?  By adjusting the ug_boring_ok+flag in mkInlineUnfoldingWithArity; see+Note [INLINE pragmas and boring contexts]++NB: there is a real risk that full laziness will float it right back+out again. Consider again+  x = factorial 200+  {-# INLINE x #-}+  f y = ...x...++After inlining we get+  f y = ...(factorial 200)...++but it's entirely possible that full laziness will do+  lvl23 = factorial 200+  f y = ...lvl23...++That's a problem for another day.++Note [INLINE pragmas and boring contexts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+An INLINE pragma uses mkInlineUnfoldingWithArity to build the+unfolding.  That sets the ug_boring_ok flag to False if the function+is not tiny (inlineBoringOK), so that even INLINE functions are not+inlined in an utterly boring context.  E.g.+     \x y. Just (f y x)+Nothing is gained by inlining f here, even if it has an INLINE+pragma.++But for 0-ary bindings, we want to inline regardless; see+Note [Honour INLINE on 0-ary bindings].++I'm a bit worried that it's possible for the same kind of problem+to arise for non-0-ary functions too, but let's wait and see.+-}++mkCoreUnfolding :: UnfoldingSource -> Bool -> CoreExpr+                -> UnfoldingGuidance -> Unfolding+-- Occurrence-analyses the expression before capturing it+mkCoreUnfolding src top_lvl expr guidance+  = CoreUnfolding { uf_tmpl         = occurAnalyseExpr_NoBinderSwap expr,+                      -- See Note [Occurrence analysis of unfoldings]+                    uf_src          = src,+                    uf_is_top       = top_lvl,+                    uf_is_value     = exprIsHNF        expr,+                    uf_is_conlike   = exprIsConLike    expr,+                    uf_is_work_free = exprIsWorkFree   expr,+                    uf_expandable   = exprIsExpandable expr,+                    uf_guidance     = guidance }++mkUnfolding :: DynFlags -> UnfoldingSource+            -> Bool       -- Is top-level+            -> Bool       -- Definitely a bottoming binding+                          -- (only relevant for top-level bindings)+            -> CoreExpr+            -> Unfolding+-- Calculates unfolding guidance+-- Occurrence-analyses the expression before capturing it+mkUnfolding dflags src is_top_lvl is_bottoming expr+  = CoreUnfolding { uf_tmpl         = occurAnalyseExpr_NoBinderSwap expr,+                      -- See Note [Occurrence analysis of unfoldings]+                    uf_src          = src,+                    uf_is_top       = is_top_lvl,+                    uf_is_value     = exprIsHNF        expr,+                    uf_is_conlike   = exprIsConLike    expr,+                    uf_expandable   = exprIsExpandable expr,+                    uf_is_work_free = exprIsWorkFree   expr,+                    uf_guidance     = guidance }+  where+    is_top_bottoming = is_top_lvl && is_bottoming+    guidance         = calcUnfoldingGuidance dflags is_top_bottoming expr+        -- NB: *not* (calcUnfoldingGuidance (occurAnalyseExpr_NoBinderSwap expr))!+        -- See Note [Calculate unfolding guidance on the non-occ-anal'd expression]++{-+Note [Occurrence analysis of unfoldings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We do occurrence-analysis of unfoldings once and for all, when the+unfolding is built, rather than each time we inline them.++But given this decision it's vital that we do+*always* do it.  Consider this unfolding+    \x -> letrec { f = ...g...; g* = f } in body+where g* is (for some strange reason) the loop breaker.  If we don't+occ-anal it when reading it in, we won't mark g as a loop breaker, and+we may inline g entirely in body, dropping its binding, and leaving+the occurrence in f out of scope. This happened in #8892, where+the unfolding in question was a DFun unfolding.++But more generally, the simplifier is designed on the+basis that it is looking at occurrence-analysed expressions, so better+ensure that they actually are.++We use occurAnalyseExpr_NoBinderSwap instead of occurAnalyseExpr;+see Note [No binder swap in unfoldings].++Note [No binder swap in unfoldings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The binder swap can temporarily violate Core Lint, by assigning+a LocalId binding to a GlobalId. For example, if A.foo{r872}+is a GlobalId with unique r872, then++ case A.foo{r872} of bar {+   K x -> ...(A.foo{r872})...+ }++gets transformed to++  case A.foo{r872} of bar {+    K x -> let foo{r872} = bar+           in ...(A.foo{r872})...++This is usually not a problem, because the simplifier will transform+this to:++  case A.foo{r872} of bar {+    K x -> ...(bar)...++However, after occurrence analysis but before simplification, this extra 'let'+violates the Core Lint invariant that we do not have local 'let' bindings for+GlobalIds.  That seems (just) tolerable for the occurrence analysis that happens+just before the Simplifier, but not for unfoldings, which are Linted+independently.+As a quick workaround, we disable binder swap in this module.+See #16288 and #16296 for further plans.++Note [Calculate unfolding guidance on the non-occ-anal'd expression]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Notice that we give the non-occur-analysed expression to+calcUnfoldingGuidance.  In some ways it'd be better to occur-analyse+first; for example, sometimes during simplification, there's a large+let-bound thing which has been substituted, and so is now dead; so+'expr' contains two copies of the thing while the occurrence-analysed+expression doesn't.++Nevertheless, we *don't* and *must not* occ-analyse before computing+the size because++a) The size computation bales out after a while, whereas occurrence+   analysis does not.++b) Residency increases sharply if you occ-anal first.  I'm not+   100% sure why, but it's a large effect.  Compiling Cabal went+   from residency of 534M to over 800M with this one change.++This can occasionally mean that the guidance is very pessimistic;+it gets fixed up next round.  And it should be rare, because large+let-bound things that are dead are usually caught by preInlineUnconditionally+++************************************************************************+*                                                                      *+\subsection{The UnfoldingGuidance type}+*                                                                      *+************************************************************************+-}++inlineBoringOk :: CoreExpr -> Bool+-- See Note [INLINE for small functions]+-- True => the result of inlining the expression is+--         no bigger than the expression itself+--     eg      (\x y -> f y x)+-- This is a quick and dirty version. It doesn't attempt+-- to deal with  (\x y z -> x (y z))+-- The really important one is (x `cast` c)+inlineBoringOk e+  = go 0 e+  where+    go :: Int -> CoreExpr -> Bool+    go credit (Lam x e) | isId x           = go (credit+1) e+                        | otherwise        = go credit e+        -- See Note [Count coercion arguments in boring contexts]+    go credit (App f (Type {}))            = go credit f+    go credit (App f a) | credit > 0+                        , exprIsTrivial a  = go (credit-1) f+    go credit (Tick _ e)                   = go credit e -- dubious+    go credit (Cast e _)                   = go credit e+    go _      (Var {})                     = boringCxtOk+    go _      _                            = boringCxtNotOk++calcUnfoldingGuidance+        :: DynFlags+        -> Bool          -- Definitely a top-level, bottoming binding+        -> CoreExpr      -- Expression to look at+        -> UnfoldingGuidance+calcUnfoldingGuidance dflags is_top_bottoming (Tick t expr)+  | not (tickishIsCode t)  -- non-code ticks don't matter for unfolding+  = calcUnfoldingGuidance dflags is_top_bottoming expr+calcUnfoldingGuidance dflags is_top_bottoming expr+  = case sizeExpr dflags bOMB_OUT_SIZE val_bndrs body of+      TooBig -> UnfNever+      SizeIs size cased_bndrs scrut_discount+        | uncondInline expr n_val_bndrs size+        -> UnfWhen { ug_unsat_ok = unSaturatedOk+                   , ug_boring_ok =  boringCxtOk+                   , ug_arity = n_val_bndrs }   -- Note [INLINE for small functions]++        | is_top_bottoming+        -> UnfNever   -- See Note [Do not inline top-level bottoming functions]++        | otherwise+        -> UnfIfGoodArgs { ug_args  = map (mk_discount cased_bndrs) val_bndrs+                         , ug_size  = size+                         , ug_res   = scrut_discount }++  where+    (bndrs, body) = collectBinders expr+    bOMB_OUT_SIZE = ufCreationThreshold dflags+           -- Bomb out if size gets bigger than this+    val_bndrs   = filter isId bndrs+    n_val_bndrs = length val_bndrs++    mk_discount :: Bag (Id,Int) -> Id -> Int+    mk_discount cbs bndr = foldl' combine 0 cbs+           where+             combine acc (bndr', disc)+               | bndr == bndr' = acc `plus_disc` disc+               | otherwise     = acc++             plus_disc :: Int -> Int -> Int+             plus_disc | isFunTy (idType bndr) = max+                       | otherwise             = (+)+             -- See Note [Function and non-function discounts]++{-+Note [Computing the size of an expression]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The basic idea of sizeExpr is obvious enough: count nodes.  But getting the+heuristics right has taken a long time.  Here's the basic strategy:++    * Variables, literals: 0+      (Exception for string literals, see litSize.)++    * Function applications (f e1 .. en): 1 + #value args++    * Constructor applications: 1, regardless of #args++    * Let(rec): 1 + size of components++    * Note, cast: 0++Examples++  Size  Term+  --------------+    0     42#+    0     x+    0     True+    2     f x+    1     Just x+    4     f (g x)++Notice that 'x' counts 0, while (f x) counts 2.  That's deliberate: there's+a function call to account for.  Notice also that constructor applications+are very cheap, because exposing them to a caller is so valuable.++[25/5/11] All sizes are now multiplied by 10, except for primops+(which have sizes like 1 or 4.  This makes primops look fantastically+cheap, and seems to be almost universally beneficial.  Done partly as a+result of #4978.++Note [Do not inline top-level bottoming functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The FloatOut pass has gone to some trouble to float out calls to 'error'+and similar friends.  See Note [Bottoming floats] in SetLevels.+Do not re-inline them!  But we *do* still inline if they are very small+(the uncondInline stuff).++Note [INLINE for small functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider        {-# INLINE f #-}+                f x = Just x+                g y = f y+Then f's RHS is no larger than its LHS, so we should inline it into+even the most boring context.  In general, f the function is+sufficiently small that its body is as small as the call itself, the+inline unconditionally, regardless of how boring the context is.++Things to note:++(1) We inline *unconditionally* if inlined thing is smaller (using sizeExpr)+    than the thing it's replacing.  Notice that+      (f x) --> (g 3)             -- YES, unconditionally+      (f x) --> x : []            -- YES, *even though* there are two+                                  --      arguments to the cons+      x     --> g 3               -- NO+      x     --> Just v            -- NO++    It's very important not to unconditionally replace a variable by+    a non-atomic term.++(2) We do this even if the thing isn't saturated, else we end up with the+    silly situation that+       f x y = x+       ...map (f 3)...+    doesn't inline.  Even in a boring context, inlining without being+    saturated will give a lambda instead of a PAP, and will be more+    efficient at runtime.++(3) However, when the function's arity > 0, we do insist that it+    has at least one value argument at the call site.  (This check is+    made in the UnfWhen case of callSiteInline.) Otherwise we find this:+         f = /\a \x:a. x+         d = /\b. MkD (f b)+    If we inline f here we get+         d = /\b. MkD (\x:b. x)+    and then prepareRhs floats out the argument, abstracting the type+    variables, so we end up with the original again!++(4) We must be much more cautious about arity-zero things. Consider+       let x = y +# z in ...+    In *size* terms primops look very small, because the generate a+    single instruction, but we do not want to unconditionally replace+    every occurrence of x with (y +# z).  So we only do the+    unconditional-inline thing for *trivial* expressions.++    NB: you might think that PostInlineUnconditionally would do this+    but it doesn't fire for top-level things; see SimplUtils+    Note [Top level and postInlineUnconditionally]++Note [Count coercion arguments in boring contexts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In inlineBoringOK, we ignore type arguments when deciding whether an+expression is okay to inline into boring contexts. This is good, since+if we have a definition like++  let y = x @Int in f y y++there’s no reason not to inline y at both use sites — no work is+actually duplicated. It may seem like the same reasoning applies to+coercion arguments, and indeed, in #17182 we changed inlineBoringOK to+treat coercions the same way.++However, this isn’t a good idea: unlike type arguments, which have+no runtime representation, coercion arguments *do* have a runtime+representation (albeit the zero-width VoidRep, see Note [Coercion tokens]+in CoreToStg.hs). This caused trouble in #17787 for DataCon wrappers for+nullary GADT constructors: the wrappers would be inlined and each use of+the constructor would lead to a separate allocation instead of just+sharing the wrapper closure.++The solution: don’t ignore coercion arguments after all.+-}++uncondInline :: CoreExpr -> Arity -> Int -> Bool+-- Inline unconditionally if there no size increase+-- Size of call is arity (+1 for the function)+-- See Note [INLINE for small functions]+uncondInline rhs arity size+  | arity > 0 = size <= 10 * (arity + 1) -- See Note [INLINE for small functions] (1)+  | otherwise = exprIsTrivial rhs        -- See Note [INLINE for small functions] (4)++sizeExpr :: DynFlags+         -> Int             -- Bomb out if it gets bigger than this+         -> [Id]            -- Arguments; we're interested in which of these+                            -- get case'd+         -> CoreExpr+         -> ExprSize++-- Note [Computing the size of an expression]++sizeExpr dflags bOMB_OUT_SIZE top_args expr+  = size_up expr+  where+    size_up (Cast e _) = size_up e+    size_up (Tick _ e) = size_up e+    size_up (Type _)   = sizeZero           -- Types cost nothing+    size_up (Coercion _) = sizeZero+    size_up (Lit lit)  = sizeN (litSize lit)+    size_up (Var f) | isRealWorldId f = sizeZero+                      -- Make sure we get constructor discounts even+                      -- on nullary constructors+                    | otherwise       = size_up_call f [] 0++    size_up (App fun arg)+      | isTyCoArg arg = size_up fun+      | otherwise     = size_up arg  `addSizeNSD`+                        size_up_app fun [arg] (if isRealWorldExpr arg then 1 else 0)++    size_up (Lam b e)+      | isId b && not (isRealWorldId b) = lamScrutDiscount dflags (size_up e `addSizeN` 10)+      | otherwise = size_up e++    size_up (Let (NonRec binder rhs) body)+      = size_up_rhs (binder, rhs) `addSizeNSD`+        size_up body              `addSizeN`+        size_up_alloc binder++    size_up (Let (Rec pairs) body)+      = foldr (addSizeNSD . size_up_rhs)+              (size_up body `addSizeN` sum (map (size_up_alloc . fst) pairs))+              pairs++    size_up (Case e _ _ alts)+        | null alts+        = size_up e    -- case e of {} never returns, so take size of scrutinee++    size_up (Case e _ _ alts)+        -- Now alts is non-empty+        | Just v <- is_top_arg e -- We are scrutinising an argument variable+        = let+            alt_sizes = map size_up_alt alts++                  -- alts_size tries to compute a good discount for+                  -- the case when we are scrutinising an argument variable+            alts_size (SizeIs tot tot_disc tot_scrut)+                          -- Size of all alternatives+                      (SizeIs max _        _)+                          -- Size of biggest alternative+                  = SizeIs tot (unitBag (v, 20 + tot - max)+                      `unionBags` tot_disc) tot_scrut+                          -- If the variable is known, we produce a+                          -- discount that will take us back to 'max',+                          -- the size of the largest alternative The+                          -- 1+ is a little discount for reduced+                          -- allocation in the caller+                          --+                          -- Notice though, that we return tot_disc,+                          -- the total discount from all branches.  I+                          -- think that's right.++            alts_size tot_size _ = tot_size+          in+          alts_size (foldr1 addAltSize alt_sizes)  -- alts is non-empty+                    (foldr1 maxSize    alt_sizes)+                -- Good to inline if an arg is scrutinised, because+                -- that may eliminate allocation in the caller+                -- And it eliminates the case itself+        where+          is_top_arg (Var v) | v `elem` top_args = Just v+          is_top_arg (Cast e _) = is_top_arg e+          is_top_arg _ = Nothing+++    size_up (Case e _ _ alts) = size_up e  `addSizeNSD`+                                foldr (addAltSize . size_up_alt) case_size alts+      where+          case_size+           | 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,+                -- below) to account for the cost of the info table+                -- and comparisons.+                --+                -- However, in certain cases (see is_inline_scrut+                -- below), no code is generated for the case unless+                -- there are multiple alts.  In these cases we+                -- subtract one, making the first alt free.+                -- e.g. case x# +# y# of _ -> ...   should cost 1+                --      case touch# x# of _ -> ...  should cost 0+                -- (see #4978)+                --+                -- 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)++                -- unboxed variables, inline primops and unsafe foreign calls+                -- are all "inline" things:+          is_inline_scrut (Var v) = isUnliftedType (idType v)+          is_inline_scrut scrut+              | (Var f, _) <- collectArgs scrut+                = case idDetails f of+                    FCallId fc  -> not (isSafeForeignCall fc)+                    PrimOpId op -> not (primOpOutOfLine op)+                    _other      -> False+              | otherwise+                = False++    size_up_rhs (bndr, rhs)+      | Just join_arity <- isJoinId_maybe bndr+        -- Skip arguments to join point+      , (_bndrs, body) <- collectNBinders join_arity rhs+      = size_up body+      | otherwise+      = size_up rhs++    ------------+    -- size_up_app is used when there's ONE OR MORE value args+    size_up_app (App fun arg) args voids+        | isTyCoArg arg                  = size_up_app fun args voids+        | isRealWorldExpr arg            = size_up_app fun (arg:args) (voids + 1)+        | otherwise                      = size_up arg  `addSizeNSD`+                                           size_up_app fun (arg:args) voids+    size_up_app (Var fun)     args voids = size_up_call fun args voids+    size_up_app (Tick _ expr) args voids = size_up_app expr args voids+    size_up_app (Cast expr _) args voids = size_up_app expr args voids+    size_up_app other         args voids = size_up other `addSizeN`+                                           callSize (length args) voids+       -- if the lhs is not an App or a Var, or an invisible thing like a+       -- Tick or Cast, then we should charge for a complete call plus the+       -- size of the lhs itself.++    ------------+    size_up_call :: Id -> [CoreExpr] -> Int -> ExprSize+    size_up_call fun val_args voids+       = case idDetails fun of+           FCallId _        -> sizeN (callSize (length val_args) voids)+           DataConWorkId dc -> conSize    dc (length val_args)+           PrimOpId op      -> primOpSize op (length val_args)+           ClassOpId _      -> classOpSize dflags top_args val_args+           _                -> funSize dflags top_args fun (length val_args) voids++    ------------+    size_up_alt (_con, _bndrs, rhs) = size_up rhs `addSizeN` 10+        -- Don't charge for args, so that wrappers look cheap+        -- (See comments about wrappers with Case)+        --+        -- 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++    ------------+    -- Cost to allocate binding with given binder+    size_up_alloc bndr+      |  isTyVar bndr                 -- Doesn't exist at runtime+      || isJoinId bndr                -- Not allocated at all+      || isUnliftedType (idType bndr) -- Doesn't live in heap+      = 0+      | otherwise+      = 10++    ------------+        -- These addSize things have to be here because+        -- I don't want to give them bOMB_OUT_SIZE as an argument+    addSizeN TooBig          _  = TooBig+    addSizeN (SizeIs n xs d) m  = mkSizeIs bOMB_OUT_SIZE (n + m) xs d++        -- addAltSize is used to add the sizes of case alternatives+    addAltSize TooBig            _      = TooBig+    addAltSize _                 TooBig = TooBig+    addAltSize (SizeIs n1 xs d1) (SizeIs n2 ys d2)+        = mkSizeIs bOMB_OUT_SIZE (n1 + n2)+                                 (xs `unionBags` ys)+                                 (d1 + d2) -- Note [addAltSize result discounts]++        -- This variant ignores the result discount from its LEFT argument+        -- It's used when the second argument isn't part of the result+    addSizeNSD TooBig            _      = TooBig+    addSizeNSD _                 TooBig = TooBig+    addSizeNSD (SizeIs n1 xs _) (SizeIs n2 ys d2)+        = mkSizeIs bOMB_OUT_SIZE (n1 + n2)+                                 (xs `unionBags` ys)+                                 d2  -- Ignore d1++    isRealWorldId id = idType id `eqType` realWorldStatePrimTy++    -- an expression of type State# RealWorld must be a variable+    isRealWorldExpr (Var id)   = isRealWorldId id+    isRealWorldExpr (Tick _ e) = isRealWorldExpr e+    isRealWorldExpr _          = False++-- | Finds a nominal size of a string literal.+litSize :: Literal -> Int+-- Used by GHC.Core.Unfold.sizeExpr+litSize (LitNumber LitNumInteger _ _) = 100   -- Note [Size of literal integers]+litSize (LitNumber LitNumNatural _ _) = 100+litSize (LitString str) = 10 + 10 * ((BS.length str + 3) `div` 4)+        -- If size could be 0 then @f "x"@ might be too small+        -- [Sept03: make literal strings a bit bigger to avoid fruitless+        --  duplication of little strings]+litSize _other = 0    -- Must match size of nullary constructors+                      -- Key point: if  x |-> 4, then x must inline unconditionally+                      --            (eg via case binding)++classOpSize :: DynFlags -> [Id] -> [CoreExpr] -> ExprSize+-- See Note [Conlike is interesting]+classOpSize _ _ []+  = sizeZero+classOpSize dflags top_args (arg1 : other_args)+  = SizeIs size arg_discount 0+  where+    size = 20 + (10 * length other_args)+    -- If the class op is scrutinising a lambda bound dictionary then+    -- give it a discount, to encourage the inlining of this function+    -- The actual discount is rather arbitrarily chosen+    arg_discount = case arg1 of+                     Var dict | dict `elem` top_args+                              -> unitBag (dict, ufDictDiscount dflags)+                     _other   -> emptyBag++-- | The size of a function call+callSize+ :: Int  -- ^ number of value args+ -> Int  -- ^ number of value args that are void+ -> Int+callSize n_val_args voids = 10 * (1 + n_val_args - voids)+        -- The 1+ is for the function itself+        -- Add 1 for each non-trivial arg;+        -- the allocation cost, as in let(rec)++-- | The size of a jump to a join point+jumpSize+ :: Int  -- ^ number of value args+ -> Int  -- ^ number of value args that are void+ -> Int+jumpSize n_val_args voids = 2 * (1 + n_val_args - voids)+  -- A jump is 20% the size of a function call. Making jumps free reopens+  -- bug #6048, but making them any more expensive loses a 21% improvement in+  -- spectral/puzzle. TODO Perhaps adjusting the default threshold would be a+  -- better solution?++funSize :: DynFlags -> [Id] -> Id -> Int -> Int -> ExprSize+-- Size for functions that are not constructors or primops+-- Note [Function applications]+funSize dflags top_args fun n_val_args voids+  | fun `hasKey` buildIdKey   = buildSize+  | fun `hasKey` augmentIdKey = augmentSize+  | otherwise = SizeIs size arg_discount res_discount+  where+    some_val_args = n_val_args > 0+    is_join = isJoinId fun++    size | is_join              = jumpSize n_val_args voids+         | not some_val_args    = 0+         | otherwise            = callSize n_val_args voids++        --                  DISCOUNTS+        --  See Note [Function and non-function discounts]+    arg_discount | some_val_args && fun `elem` top_args+                 = unitBag (fun, ufFunAppDiscount dflags)+                 | otherwise = emptyBag+        -- If the function is an argument and is applied+        -- to some values, give it an arg-discount++    res_discount | idArity fun > n_val_args = ufFunAppDiscount dflags+                 | otherwise                = 0+        -- If the function is partially applied, show a result discount+-- XXX maybe behave like ConSize for eval'd variable++conSize :: DataCon -> Int -> ExprSize+conSize dc n_val_args+  | n_val_args == 0 = SizeIs 0 emptyBag 10    -- Like variables++-- See Note [Unboxed tuple size and result discount]+  | isUnboxedTupleCon dc = SizeIs 0 emptyBag (10 * (1 + n_val_args))++-- See Note [Constructor size and result discount]+  | otherwise = SizeIs 10 emptyBag (10 * (1 + n_val_args))++-- XXX still looks to large to me++{-+Note [Constructor size and result discount]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Treat a constructors application as size 10, regardless of how many+arguments it has; we are keen to expose them (and we charge separately+for their args).  We can't treat them as size zero, else we find that+(Just x) has size 0, which is the same as a lone variable; and hence+'v' will always be replaced by (Just x), where v is bound to Just x.++The "result discount" is applied if the result of the call is+scrutinised (say by a case).  For a constructor application that will+mean the constructor application will disappear, so we don't need to+charge it to the function.  So the discount should at least match the+cost of the constructor application, namely 10.  But to give a bit+of extra incentive we give a discount of 10*(1 + n_val_args).++Simon M tried a MUCH bigger discount: (10 * (10 + n_val_args)),+and said it was an "unambiguous win", but its terribly dangerous+because a function with many many case branches, each finishing with+a constructor, can have an arbitrarily large discount.  This led to+terrible code bloat: see #6099.++Note [Unboxed tuple size and result discount]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+However, unboxed tuples count as size zero. I found occasions where we had+        f x y z = case op# x y z of { s -> (# s, () #) }+and f wasn't getting inlined.++I tried giving unboxed tuples a *result discount* of zero (see the+commented-out line).  Why?  When returned as a result they do not+allocate, so maybe we don't want to charge so much for them If you+have a non-zero discount here, we find that workers often get inlined+back into wrappers, because it look like+    f x = case $wf x of (# a,b #) -> (a,b)+and we are keener because of the case.  However while this change+shrank binary sizes by 0.5% it also made spectral/boyer allocate 5%+more. All other changes were very small. So it's not a big deal but I+didn't adopt the idea.++Note [Function and non-function discounts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We want a discount if the function is applied. A good example is+monadic combinators with continuation arguments, where inlining is+quite important.++But we don't want a big discount when a function is called many times+(see the detailed comments with #6048) because if the function is+big it won't be inlined at its many call sites and no benefit results.+Indeed, we can get exponentially big inlinings this way; that is what+#6048 is about.++On the other hand, for data-valued arguments, if there are lots of+case expressions in the body, each one will get smaller if we apply+the function to a constructor application, so we *want* a big discount+if the argument is scrutinised by many case expressions.++Conclusion:+  - For functions, take the max of the discounts+  - For data values, take the sum of the discounts+++Note [Literal integer size]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Literal integers *can* be big (mkInteger [...coefficients...]), but+need not be (S# n).  We just use an arbitrary big-ish constant here+so that, in particular, we don't inline top-level defns like+   n = S# 5+There's no point in doing so -- any optimisations will see the S#+through n's unfolding.  Nor will a big size inhibit unfoldings functions+that mention a literal Integer, because the float-out pass will float+all those constants to top level.+-}++primOpSize :: PrimOp -> Int -> ExprSize+primOpSize op n_val_args+ = if primOpOutOfLine op+      then sizeN (op_size + n_val_args)+      else sizeN op_size+ where+   op_size = primOpCodeSize op+++buildSize :: ExprSize+buildSize = SizeIs 0 emptyBag 40+        -- We really want to inline applications of build+        -- build t (\cn -> e) should cost only the cost of e (because build will be inlined later)+        -- Indeed, we should add a result_discount because build is+        -- very like a constructor.  We don't bother to check that the+        -- build is saturated (it usually is).  The "-2" discounts for the \c n,+        -- The "4" is rather arbitrary.++augmentSize :: ExprSize+augmentSize = SizeIs 0 emptyBag 40+        -- Ditto (augment t (\cn -> e) ys) should cost only the cost of+        -- e plus ys. The -2 accounts for the \cn++-- When we return a lambda, give a discount if it's used (applied)+lamScrutDiscount :: DynFlags -> ExprSize -> ExprSize+lamScrutDiscount dflags (SizeIs n vs _) = SizeIs n vs (ufFunAppDiscount dflags)+lamScrutDiscount _      TooBig          = TooBig++{-+Note [addAltSize result discounts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When adding the size of alternatives, we *add* the result discounts+too, rather than take the *maximum*.  For a multi-branch case, this+gives a discount for each branch that returns a constructor, making us+keener to inline.  I did try using 'max' instead, but it makes nofib+'rewrite' and 'puzzle' allocate significantly more, and didn't make+binary sizes shrink significantly either.++Note [Discounts and thresholds]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Constants for discounts and thesholds are defined in main/DynFlags,+all of form ufXxxx.   They are:++ufCreationThreshold+     At a definition site, if the unfolding is bigger than this, we+     may discard it altogether++ufUseThreshold+     At a call site, if the unfolding, less discounts, is smaller than+     this, then it's small enough inline++ufKeenessFactor+     Factor by which the discounts are multiplied before+     subtracting from size++ufDictDiscount+     The discount for each occurrence of a dictionary argument+     as an argument of a class method.  Should be pretty small+     else big functions may get inlined++ufFunAppDiscount+     Discount for a function argument that is applied.  Quite+     large, because if we inline we avoid the higher-order call.++ufDearOp+     The size of a foreign call or not-dupable PrimOp++ufVeryAggressive+     If True, the compiler ignores all the thresholds and inlines very+     aggressively. It still adheres to arity, simplifier phase control and+     loop breakers.+++Note [Function applications]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In a function application (f a b)++  - If 'f' is an argument to the function being analysed,+    and there's at least one value arg, record a FunAppDiscount for f++  - If the application if a PAP (arity > 2 in this example)+    record a *result* discount (because inlining+    with "extra" args in the call may mean that we now+    get a saturated application)++Code for manipulating sizes+-}++-- | The size of a candidate expression for unfolding+data ExprSize+    = TooBig+    | SizeIs { _es_size_is  :: {-# UNPACK #-} !Int -- ^ Size found+             , _es_args     :: !(Bag (Id,Int))+               -- ^ Arguments cased herein, and discount for each such+             , _es_discount :: {-# UNPACK #-} !Int+               -- ^ Size to subtract if result is scrutinised by a case+               -- expression+             }++instance Outputable ExprSize where+  ppr TooBig         = text "TooBig"+  ppr (SizeIs a _ c) = brackets (int a <+> int c)++-- subtract the discount before deciding whether to bale out. eg. we+-- want to inline a large constructor application into a selector:+--      tup = (a_1, ..., a_99)+--      x = case tup of ...+--+mkSizeIs :: Int -> Int -> Bag (Id, Int) -> Int -> ExprSize+mkSizeIs max n xs d | (n - d) > max = TooBig+                    | otherwise     = SizeIs n xs d++maxSize :: ExprSize -> ExprSize -> ExprSize+maxSize TooBig         _                                  = TooBig+maxSize _              TooBig                             = TooBig+maxSize s1@(SizeIs n1 _ _) s2@(SizeIs n2 _ _) | n1 > n2   = s1+                                              | otherwise = s2++sizeZero :: ExprSize+sizeN :: Int -> ExprSize++sizeZero = SizeIs 0 emptyBag 0+sizeN n  = SizeIs n emptyBag 0++{-+************************************************************************+*                                                                      *+\subsection[considerUnfolding]{Given all the info, do (not) do the unfolding}+*                                                                      *+************************************************************************++We use 'couldBeSmallEnoughToInline' to avoid exporting inlinings that+we ``couldn't possibly use'' on the other side.  Can be overridden w/+flaggery.  Just the same as smallEnoughToInline, except that it has no+actual arguments.+-}++couldBeSmallEnoughToInline :: DynFlags -> Int -> CoreExpr -> Bool+couldBeSmallEnoughToInline dflags threshold rhs+  = case sizeExpr dflags threshold [] body of+       TooBig -> False+       _      -> True+  where+    (_, body) = collectBinders rhs++----------------+smallEnoughToInline :: DynFlags -> Unfolding -> Bool+smallEnoughToInline dflags (CoreUnfolding {uf_guidance = UnfIfGoodArgs {ug_size = size}})+  = size <= ufUseThreshold dflags+smallEnoughToInline _ _+  = False++----------------++certainlyWillInline :: DynFlags -> IdInfo -> Maybe Unfolding+-- ^ Sees if the unfolding is pretty certain to inline.+-- If so, return a *stable* unfolding for it, that will always inline.+certainlyWillInline dflags fn_info+  = case unfoldingInfo fn_info of+      CoreUnfolding { uf_tmpl = e, uf_guidance = g }+        | loop_breaker -> Nothing      -- Won't inline, so try w/w+        | noinline     -> Nothing      -- See Note [Worker-wrapper for NOINLINE functions]+        | otherwise    -> do_cunf e g  -- Depends on size, so look at that++      DFunUnfolding {} -> Just fn_unf  -- Don't w/w DFuns; it never makes sense+                                       -- to do so, and even if it is currently a+                                       -- loop breaker, it may not be later++      _other_unf       -> Nothing++  where+    loop_breaker = isStrongLoopBreaker (occInfo fn_info)+    noinline     = inlinePragmaSpec (inlinePragInfo fn_info) == NoInline+    fn_unf       = unfoldingInfo fn_info++    do_cunf :: CoreExpr -> UnfoldingGuidance -> Maybe Unfolding+    do_cunf _ UnfNever     = Nothing+    do_cunf _ (UnfWhen {}) = Just (fn_unf { uf_src = InlineStable })+                             -- INLINE functions have UnfWhen++        -- The UnfIfGoodArgs case seems important.  If we w/w small functions+        -- binary sizes go up by 10%!  (This is with SplitObjs.)+        -- I'm not totally sure why.+        -- INLINABLE functions come via this path+        --    See Note [certainlyWillInline: INLINABLE]+    do_cunf expr (UnfIfGoodArgs { ug_size = size, ug_args = args })+      | arityInfo fn_info > 0  -- See Note [certainlyWillInline: be careful of thunks]+      , not (isBottomingSig (strictnessInfo fn_info))+              -- Do not unconditionally inline a bottoming functions even if+              -- it seems smallish. We've carefully lifted it out to top level,+              -- so we don't want to re-inline it.+      , let unf_arity = length args+      , size - (10 * (unf_arity + 1)) <= ufUseThreshold dflags+      = Just (fn_unf { uf_src      = InlineStable+                     , uf_guidance = UnfWhen { ug_arity     = unf_arity+                                             , ug_unsat_ok  = unSaturatedOk+                                             , ug_boring_ok = inlineBoringOk expr } })+             -- Note the "unsaturatedOk". A function like  f = \ab. a+             -- will certainly inline, even if partially applied (f e), so we'd+             -- better make sure that the transformed inlining has the same property+      | otherwise+      = Nothing++{- Note [certainlyWillInline: be careful of thunks]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Don't claim that thunks will certainly inline, because that risks work+duplication.  Even if the work duplication is not great (eg is_cheap+holds), it can make a big difference in an inner loop In #5623 we+found that the WorkWrap phase thought that+       y = case x of F# v -> F# (v +# v)+was certainlyWillInline, so the addition got duplicated.++Note that we check arityInfo instead of the arity of the unfolding to detect+this case. This is so that we don't accidentally fail to inline small partial+applications, like `f = g 42` (where `g` recurses into `f`) where g has arity 2+(say). Here there is no risk of work duplication, and the RHS is tiny, so+certainlyWillInline should return True. But `unf_arity` is zero! However f's+arity, gotten from `arityInfo fn_info`, is 1.++Failing to say that `f` will inline forces W/W to generate a potentially huge+worker for f that will immediately cancel with `g`'s wrapper anyway, causing+unnecessary churn in the Simplifier while arriving at the same result.++Note [certainlyWillInline: INLINABLE]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+certainlyWillInline /must/ return Nothing for a large INLINABLE thing,+even though we have a stable inlining, so that strictness w/w takes+place.  It makes a big difference to efficiency, and the w/w pass knows+how to transfer the INLINABLE info to the worker; see WorkWrap+Note [Worker-wrapper for INLINABLE functions]++************************************************************************+*                                                                      *+\subsection{callSiteInline}+*                                                                      *+************************************************************************++This is the key function.  It decides whether to inline a variable at a call site++callSiteInline is used at call sites, so it is a bit more generous.+It's a very important function that embodies lots of heuristics.+A non-WHNF can be inlined if it doesn't occur inside a lambda,+and occurs exactly once or+    occurs once in each branch of a case and is small++If the thing is in WHNF, there's no danger of duplicating work,+so we can inline if it occurs once, or is small++NOTE: we don't want to inline top-level functions that always diverge.+It just makes the code bigger.  Tt turns out that the convenient way to prevent+them inlining is to give them a NOINLINE pragma, which we do in+StrictAnal.addStrictnessInfoToTopId+-}++callSiteInline :: DynFlags+               -> Id                    -- The Id+               -> Bool                  -- True <=> unfolding is active+               -> Bool                  -- True if there are no arguments at all (incl type args)+               -> [ArgSummary]          -- One for each value arg; True if it is interesting+               -> CallCtxt              -- True <=> continuation is interesting+               -> Maybe CoreExpr        -- Unfolding, if any++data ArgSummary = TrivArg       -- Nothing interesting+                | NonTrivArg    -- Arg has structure+                | ValueArg      -- Arg is a con-app or PAP+                                -- ..or con-like. Note [Conlike is interesting]++instance Outputable ArgSummary where+  ppr TrivArg    = text "TrivArg"+  ppr NonTrivArg = text "NonTrivArg"+  ppr ValueArg   = text "ValueArg"++nonTriv ::  ArgSummary -> Bool+nonTriv TrivArg = False+nonTriv _       = True++data CallCtxt+  = BoringCtxt+  | RhsCtxt             -- Rhs of a let-binding; see Note [RHS of lets]+  | DiscArgCtxt         -- Argument of a function with non-zero arg discount+  | RuleArgCtxt         -- We are somewhere in the argument of a function with rules++  | ValAppCtxt          -- We're applied to at least one value arg+                        -- This arises when we have ((f x |> co) y)+                        -- Then the (f x) has argument 'x' but in a ValAppCtxt++  | CaseCtxt            -- We're the scrutinee of a case+                        -- that decomposes its scrutinee++instance Outputable CallCtxt where+  ppr CaseCtxt    = text "CaseCtxt"+  ppr ValAppCtxt  = text "ValAppCtxt"+  ppr BoringCtxt  = text "BoringCtxt"+  ppr RhsCtxt     = text "RhsCtxt"+  ppr DiscArgCtxt = text "DiscArgCtxt"+  ppr RuleArgCtxt = text "RuleArgCtxt"++callSiteInline dflags id active_unfolding lone_variable arg_infos cont_info+  = case idUnfolding id of+      -- idUnfolding checks for loop-breakers, returning NoUnfolding+      -- Things with an INLINE pragma may have an unfolding *and*+      -- be a loop breaker  (maybe the knot is not yet untied)+        CoreUnfolding { uf_tmpl = unf_template+                      , uf_is_work_free = is_wf+                      , uf_guidance = guidance, uf_expandable = is_exp }+          | active_unfolding -> tryUnfolding dflags id lone_variable+                                    arg_infos cont_info unf_template+                                    is_wf is_exp guidance+          | otherwise -> traceInline dflags id "Inactive unfolding:" (ppr id) Nothing+        NoUnfolding      -> Nothing+        BootUnfolding    -> Nothing+        OtherCon {}      -> Nothing+        DFunUnfolding {} -> Nothing     -- Never unfold a DFun++traceInline :: DynFlags -> Id -> String -> SDoc -> a -> a+traceInline dflags inline_id str doc result+ | Just prefix <- inlineCheck dflags+ =  if prefix `isPrefixOf` occNameString (getOccName inline_id)+      then traceAction dflags str doc result+      else result+ | dopt Opt_D_dump_inlinings dflags && dopt Opt_D_verbose_core2core dflags+ = traceAction dflags str doc result+ | otherwise+ = result++tryUnfolding :: DynFlags -> Id -> Bool -> [ArgSummary] -> CallCtxt+             -> CoreExpr -> Bool -> Bool -> UnfoldingGuidance+             -> Maybe CoreExpr+tryUnfolding dflags id lone_variable+             arg_infos cont_info unf_template+             is_wf is_exp guidance+ = case guidance of+     UnfNever -> traceInline dflags id str (text "UnfNever") Nothing++     UnfWhen { ug_arity = uf_arity, ug_unsat_ok = unsat_ok, ug_boring_ok = boring_ok }+        | enough_args && (boring_ok || some_benefit || ufVeryAggressive dflags)+                -- See Note [INLINE for small functions (3)]+        -> traceInline dflags id str (mk_doc some_benefit empty True) (Just unf_template)+        | otherwise+        -> traceInline dflags id str (mk_doc some_benefit empty False) Nothing+        where+          some_benefit = calc_some_benefit uf_arity+          enough_args = (n_val_args >= uf_arity) || (unsat_ok && n_val_args > 0)++     UnfIfGoodArgs { ug_args = arg_discounts, ug_res = res_discount, ug_size = size }+        | ufVeryAggressive dflags+        -> traceInline dflags id str (mk_doc some_benefit extra_doc True) (Just unf_template)+        | is_wf && some_benefit && small_enough+        -> traceInline dflags id str (mk_doc some_benefit extra_doc True) (Just unf_template)+        | otherwise+        -> traceInline dflags id str (mk_doc some_benefit extra_doc False) Nothing+        where+          some_benefit = calc_some_benefit (length arg_discounts)+          extra_doc = text "discounted size =" <+> int discounted_size+          discounted_size = size - discount+          small_enough = discounted_size <= ufUseThreshold dflags+          discount = computeDiscount dflags arg_discounts+                                     res_discount arg_infos cont_info++  where+    mk_doc some_benefit extra_doc yes_or_no+      = vcat [ text "arg infos" <+> ppr arg_infos+             , text "interesting continuation" <+> ppr cont_info+             , text "some_benefit" <+> ppr some_benefit+             , text "is exp:" <+> ppr is_exp+             , text "is work-free:" <+> ppr is_wf+             , text "guidance" <+> ppr guidance+             , extra_doc+             , text "ANSWER =" <+> if yes_or_no then text "YES" else text "NO"]++    str = "Considering inlining: " ++ showSDocDump dflags (ppr id)+    n_val_args = length arg_infos++           -- some_benefit is used when the RHS is small enough+           -- and the call has enough (or too many) value+           -- arguments (ie n_val_args >= arity). But there must+           -- be *something* interesting about some argument, or the+           -- result context, to make it worth inlining+    calc_some_benefit :: Arity -> Bool   -- The Arity is the number of args+                                         -- expected by the unfolding+    calc_some_benefit uf_arity+       | not saturated = interesting_args       -- Under-saturated+                                        -- Note [Unsaturated applications]+       | otherwise = interesting_args   -- Saturated or over-saturated+                  || interesting_call+      where+        saturated      = n_val_args >= uf_arity+        over_saturated = n_val_args > uf_arity+        interesting_args = any nonTriv arg_infos+                -- NB: (any nonTriv arg_infos) looks at the+                -- over-saturated args too which is "wrong";+                -- but if over-saturated we inline anyway.++        interesting_call+          | over_saturated+          = True+          | otherwise+          = case cont_info of+              CaseCtxt   -> not (lone_variable && is_exp)  -- Note [Lone variables]+              ValAppCtxt -> True                           -- Note [Cast then apply]+              RuleArgCtxt -> uf_arity > 0  -- See Note [Unfold info lazy contexts]+              DiscArgCtxt -> uf_arity > 0  -- Note [Inlining in ArgCtxt]+              RhsCtxt     -> uf_arity > 0  --+              _other      -> False         -- See Note [Nested functions]+++{-+Note [Unfold into lazy contexts], Note [RHS of lets]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When the call is the argument of a function with a RULE, or the RHS of a let,+we are a little bit keener to inline.  For example+     f y = (y,y,y)+     g y = let x = f y in ...(case x of (a,b,c) -> ...) ...+We'd inline 'f' if the call was in a case context, and it kind-of-is,+only we can't see it.  Also+     x = f v+could be expensive whereas+     x = case v of (a,b) -> a+is patently cheap and may allow more eta expansion.+So we treat the RHS of a let as not-totally-boring.++Note [Unsaturated applications]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When a call is not saturated, we *still* inline if one of the+arguments has interesting structure.  That's sometimes very important.+A good example is the Ord instance for Bool in Base:++ Rec {+    $fOrdBool =GHC.Classes.D:Ord+                 @ Bool+                 ...+                 $cmin_ajX++    $cmin_ajX [Occ=LoopBreaker] :: Bool -> Bool -> Bool+    $cmin_ajX = GHC.Classes.$dmmin @ Bool $fOrdBool+  }++But the defn of GHC.Classes.$dmmin is:++  $dmmin :: forall a. GHC.Classes.Ord a => a -> a -> a+    {- Arity: 3, HasNoCafRefs, Strictness: SLL,+       Unfolding: (\ @ a $dOrd :: GHC.Classes.Ord a x :: a y :: a ->+                   case @ a GHC.Classes.<= @ a $dOrd x y of wild {+                     GHC.Types.False -> y GHC.Types.True -> x }) -}++We *really* want to inline $dmmin, even though it has arity 3, in+order to unravel the recursion.+++Note [Things to watch]+~~~~~~~~~~~~~~~~~~~~~~+*   { y = I# 3; x = y `cast` co; ...case (x `cast` co) of ... }+    Assume x is exported, so not inlined unconditionally.+    Then we want x to inline unconditionally; no reason for it+    not to, and doing so avoids an indirection.++*   { x = I# 3; ....f x.... }+    Make sure that x does not inline unconditionally!+    Lest we get extra allocation.++Note [Inlining an InlineRule]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+An InlineRules is used for+  (a) programmer INLINE pragmas+  (b) inlinings from worker/wrapper++For (a) the RHS may be large, and our contract is that we *only* inline+when the function is applied to all the arguments on the LHS of the+source-code defn.  (The uf_arity in the rule.)++However for worker/wrapper it may be worth inlining even if the+arity is not satisfied (as we do in the CoreUnfolding case) so we don't+require saturation.++Note [Nested functions]+~~~~~~~~~~~~~~~~~~~~~~~+At one time we treated a call of a non-top-level function as+"interesting" (regardless of how boring the context) in the hope+that inlining it would eliminate the binding, and its allocation.+Specifically, in the default case of interesting_call we had+   _other -> not is_top && uf_arity > 0++But actually postInlineUnconditionally does some of this and overall+it makes virtually no difference to nofib.  So I simplified away this+special case++Note [Cast then apply]+~~~~~~~~~~~~~~~~~~~~~~+Consider+   myIndex = __inline_me ( (/\a. <blah>) |> co )+   co :: (forall a. a -> a) ~ (forall a. T a)+     ... /\a.\x. case ((myIndex a) |> sym co) x of { ... } ...++We need to inline myIndex to unravel this; but the actual call (myIndex a) has+no value arguments.  The ValAppCtxt gives it enough incentive to inline.++Note [Inlining in ArgCtxt]+~~~~~~~~~~~~~~~~~~~~~~~~~~+The condition (arity > 0) here is very important, because otherwise+we end up inlining top-level stuff into useless places; eg+   x = I# 3#+   f = \y.  g x+This can make a very big difference: it adds 16% to nofib 'integer' allocs,+and 20% to 'power'.++At one stage I replaced this condition by 'True' (leading to the above+slow-down).  The motivation was test eyeball/inline1.hs; but that seems+to work ok now.++NOTE: arguably, we should inline in ArgCtxt only if the result of the+call is at least CONLIKE.  At least for the cases where we use ArgCtxt+for the RHS of a 'let', we only profit from the inlining if we get a+CONLIKE thing (modulo lets).++Note [Lone variables]   See also Note [Interaction of exprIsWorkFree and lone variables]+~~~~~~~~~~~~~~~~~~~~~   which appears below+The "lone-variable" case is important.  I spent ages messing about+with unsatisfactory variants, but this is nice.  The idea is that if a+variable appears all alone++        as an arg of lazy fn, or rhs    BoringCtxt+        as scrutinee of a case          CaseCtxt+        as arg of a fn                  ArgCtxt+AND+        it is bound to a cheap expression++then we should not inline it (unless there is some other reason,+e.g. it is the sole occurrence).  That is what is happening at+the use of 'lone_variable' in 'interesting_call'.++Why?  At least in the case-scrutinee situation, turning+        let x = (a,b) in case x of y -> ...+into+        let x = (a,b) in case (a,b) of y -> ...+and thence to+        let x = (a,b) in let y = (a,b) in ...+is bad if the binding for x will remain.++Another example: I discovered that strings+were getting inlined straight back into applications of 'error'+because the latter is strict.+        s = "foo"+        f = \x -> ...(error s)...++Fundamentally such contexts should not encourage inlining because, provided+the RHS is "expandable" (see Note [exprIsExpandable] in GHC.Core.Utils) the+context can ``see'' the unfolding of the variable (e.g. case or a+RULE) so there's no gain.++However, watch out:++ * Consider this:+        foo = _inline_ (\n. [n])+        bar = _inline_ (foo 20)+        baz = \n. case bar of { (m:_) -> m + n }+   Here we really want to inline 'bar' so that we can inline 'foo'+   and the whole thing unravels as it should obviously do.  This is+   important: in the NDP project, 'bar' generates a closure data+   structure rather than a list.++   So the non-inlining of lone_variables should only apply if the+   unfolding is regarded as cheap; because that is when exprIsConApp_maybe+   looks through the unfolding.  Hence the "&& is_wf" in the+   InlineRule branch.++ * Even a type application or coercion isn't a lone variable.+   Consider+        case $fMonadST @ RealWorld of { :DMonad a b c -> c }+   We had better inline that sucker!  The case won't see through it.++   For now, I'm treating treating a variable applied to types+   in a *lazy* context "lone". The motivating example was+        f = /\a. \x. BIG+        g = /\a. \y.  h (f a)+   There's no advantage in inlining f here, and perhaps+   a significant disadvantage.  Hence some_val_args in the Stop case++Note [Interaction of exprIsWorkFree and lone variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The lone-variable test says "don't inline if a case expression+scrutinises a lone variable whose unfolding is cheap".  It's very+important that, under these circumstances, exprIsConApp_maybe+can spot a constructor application. So, for example, we don't+consider+        let x = e in (x,x)+to be cheap, and that's good because exprIsConApp_maybe doesn't+think that expression is a constructor application.++In the 'not (lone_variable && is_wf)' test, I used to test is_value+rather than is_wf, which was utterly wrong, because the above+expression responds True to exprIsHNF, which is what sets is_value.++This kind of thing can occur if you have++        {-# INLINE foo #-}+        foo = let x = e in (x,x)++which Roman did.+++-}++computeDiscount :: DynFlags -> [Int] -> Int -> [ArgSummary] -> CallCtxt+                -> Int+computeDiscount dflags arg_discounts res_discount arg_infos cont_info+        -- We multiple the raw discounts (args_discount and result_discount)+        -- ty opt_UnfoldingKeenessFactor because the former have to do with+        --  *size* whereas the discounts imply that there's some extra+        --  *efficiency* to be gained (e.g. beta reductions, case reductions)+        -- by inlining.++  = 10          -- Discount of 10 because the result replaces the call+                -- so we count 10 for the function itself++    + 10 * length actual_arg_discounts+               -- Discount of 10 for each arg supplied,+               -- because the result replaces the call++    + round (ufKeenessFactor dflags *+             fromIntegral (total_arg_discount + res_discount'))+  where+    actual_arg_discounts = zipWith mk_arg_discount arg_discounts arg_infos+    total_arg_discount   = sum actual_arg_discounts++    mk_arg_discount _        TrivArg    = 0+    mk_arg_discount _        NonTrivArg = 10+    mk_arg_discount discount ValueArg   = discount++    res_discount'+      | LT <- arg_discounts `compareLength` arg_infos+      = 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+                -- 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+                --   for RuleArgCtxt we do want to be keener to inline; but not only+                --       constructor results+                --   for RhsCtxt I suppose that exposing a data con is good in general+                --   And 40 seems very arbitrary+                --+                -- res_discount can be very large when a function returns+                -- constructors; but we only want to invoke that large discount+                -- when there's a case continuation.+                -- Otherwise we, rather arbitrarily, threshold it.  Yuk.+                -- But we want to avoid inlining large functions that return+                -- constructors into contexts that are simply "interesting"

+ compiler/GHC/Core/Unfold.hs-boot view

@@ -0,0 +1,16 @@+module GHC.Core.Unfold (+        mkUnfolding, mkInlineUnfolding+    ) where++import GhcPrelude+import GHC.Core+import GHC.Driver.Session++mkInlineUnfolding :: CoreExpr -> Unfolding++mkUnfolding :: DynFlags+            -> UnfoldingSource+            -> Bool+            -> Bool+            -> CoreExpr+            -> Unfolding

+ compiler/GHC/Core/Utils.hs view

@@ -0,0 +1,2567 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+++Utility functions on @Core@ syntax+-}++{-# LANGUAGE CPP #-}++-- | Commonly useful utilities for manipulating the Core language+module GHC.Core.Utils (+        -- * Constructing expressions+        mkCast,+        mkTick, mkTicks, mkTickNoHNF, tickHNFArgs,+        bindNonRec, needsCaseBinding,+        mkAltExpr, mkDefaultCase, mkSingleAltCase,++        -- * Taking expressions apart+        findDefault, addDefault, findAlt, isDefaultAlt,+        mergeAlts, trimConArgs,+        filterAlts, combineIdenticalAlts, refineDefaultAlt,++        -- * Properties of expressions+        exprType, coreAltType, coreAltsType, isExprLevPoly,+        exprIsDupable, exprIsTrivial, getIdFromTrivialExpr, exprIsBottom,+        getIdFromTrivialExpr_maybe,+        exprIsCheap, exprIsExpandable, exprIsCheapX, CheapAppFun,+        exprIsHNF, exprOkForSpeculation, exprOkForSideEffects, exprIsWorkFree,+        exprIsBig, exprIsConLike,+        isCheapApp, isExpandableApp,+        exprIsTickedString, exprIsTickedString_maybe,+        exprIsTopLevelBindable,+        altsAreExhaustive,++        -- * Equality+        cheapEqExpr, cheapEqExpr', eqExpr,+        diffExpr, diffBinds,++        -- * Eta reduction+        tryEtaReduce,++        -- * Manipulating data constructors and types+        exprToType, exprToCoercion_maybe,+        applyTypeToArgs, applyTypeToArg,+        dataConRepInstPat, dataConRepFSInstPat,+        isEmptyTy,++        -- * Working with ticks+        stripTicksTop, stripTicksTopE, stripTicksTopT,+        stripTicksE, stripTicksT,++        -- * StaticPtr+        collectMakeStaticArgs,++        -- * Join points+        isJoinBind,++        -- * Dumping stuff+        dumpIdInfoOfProgram+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Core+import PrelNames ( makeStaticName )+import GHC.Core.Ppr+import GHC.Core.FVs( exprFreeVars )+import Var+import SrcLoc+import VarEnv+import VarSet+import Name+import Literal+import DataCon+import PrimOp+import Id+import IdInfo+import PrelNames( absentErrorIdKey )+import Type+import Predicate+import TyCoRep( TyCoBinder(..), TyBinder )+import Coercion+import TyCon+import Unique+import Outputable+import TysPrim+import GHC.Driver.Session+import FastString+import Maybes+import ListSetOps       ( minusList )+import BasicTypes       ( Arity, isConLike )+import Util+import Pair+import Data.ByteString     ( ByteString )+import Data.Function       ( on )+import Data.List+import Data.Ord            ( comparing )+import OrdList+import qualified Data.Set as Set+import UniqSet++{-+************************************************************************+*                                                                      *+\subsection{Find the type of a Core atom/expression}+*                                                                      *+************************************************************************+-}++exprType :: CoreExpr -> Type+-- ^ Recover the type of a well-typed Core expression. Fails when+-- applied to the actual 'GHC.Core.Type' expression as it cannot+-- really be said to have a type+exprType (Var var)           = idType var+exprType (Lit lit)           = literalType lit+exprType (Coercion co)       = coercionType co+exprType (Let bind body)+  | NonRec tv rhs <- bind    -- See Note [Type bindings]+  , Type ty <- rhs           = substTyWithUnchecked [tv] [ty] (exprType body)+  | otherwise                = exprType body+exprType (Case _ _ ty _)     = ty+exprType (Cast _ co)         = pSnd (coercionKind co)+exprType (Tick _ e)          = exprType e+exprType (Lam binder expr)   = mkLamType binder (exprType expr)+exprType e@(App _ _)+  = case collectArgs e of+        (fun, args) -> applyTypeToArgs e (exprType fun) args++exprType other = pprTrace "exprType" (pprCoreExpr other) alphaTy++coreAltType :: CoreAlt -> Type+-- ^ Returns the type of the alternatives right hand side+coreAltType alt@(_,bs,rhs)+  = case occCheckExpand bs rhs_ty of+      -- Note [Existential variables and silly type synonyms]+      Just ty -> ty+      Nothing -> pprPanic "coreAltType" (pprCoreAlt alt $$ ppr rhs_ty)+  where+    rhs_ty = exprType rhs++coreAltsType :: [CoreAlt] -> Type+-- ^ Returns the type of the first alternative, which should be the same as for all alternatives+coreAltsType (alt:_) = coreAltType alt+coreAltsType []      = panic "corAltsType"++-- | Is this expression levity polymorphic? This should be the+-- same as saying (isKindLevPoly . typeKind . exprType) but+-- much faster.+isExprLevPoly :: CoreExpr -> Bool+isExprLevPoly = go+  where+   go (Var _)                      = False  -- no levity-polymorphic binders+   go (Lit _)                      = False  -- no levity-polymorphic literals+   go e@(App f _) | not (go_app f) = False+                  | otherwise      = check_type e+   go (Lam _ _)                    = False+   go (Let _ e)                    = go e+   go e@(Case {})                  = check_type e -- checking type is fast+   go e@(Cast {})                  = check_type e+   go (Tick _ e)                   = go e+   go e@(Type {})                  = pprPanic "isExprLevPoly ty" (ppr e)+   go (Coercion {})                = False  -- this case can happen in SetLevels++   check_type = isTypeLevPoly . exprType  -- slow approach++      -- if the function is a variable (common case), check its+      -- levityInfo. This might mean we don't need to look up and compute+      -- on the type. Spec of these functions: return False if there is+      -- no possibility, ever, of this expression becoming levity polymorphic,+      -- no matter what it's applied to; return True otherwise.+      -- returning True is always safe. See also Note [Levity info] in+      -- IdInfo+   go_app (Var id)        = not (isNeverLevPolyId id)+   go_app (Lit _)         = False+   go_app (App f _)       = go_app f+   go_app (Lam _ e)       = go_app e+   go_app (Let _ e)       = go_app e+   go_app (Case _ _ ty _) = resultIsLevPoly ty+   go_app (Cast _ co)     = resultIsLevPoly (coercionRKind co)+   go_app (Tick _ e)      = go_app e+   go_app e@(Type {})     = pprPanic "isExprLevPoly app ty" (ppr e)+   go_app e@(Coercion {}) = pprPanic "isExprLevPoly app co" (ppr e)+++{-+Note [Type bindings]+~~~~~~~~~~~~~~~~~~~~+Core does allow type bindings, although such bindings are+not much used, except in the output of the desugarer.+Example:+     let a = Int in (\x:a. x)+Given this, exprType must be careful to substitute 'a' in the+result type (#8522).++Note [Existential variables and silly type synonyms]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+        data T = forall a. T (Funny a)+        type Funny a = Bool+        f :: T -> Bool+        f (T x) = x++Now, the type of 'x' is (Funny a), where 'a' is existentially quantified.+That means that 'exprType' and 'coreAltsType' may give a result that *appears*+to mention an out-of-scope type variable.  See #3409 for a more real-world+example.++Various possibilities suggest themselves:++ - Ignore the problem, and make Lint not complain about such variables++ - Expand all type synonyms (or at least all those that discard arguments)+      This is tricky, because at least for top-level things we want to+      retain the type the user originally specified.++ - Expand synonyms on the fly, when the problem arises. That is what+   we are doing here.  It's not too expensive, I think.++Note that there might be existentially quantified coercion variables, too.+-}++-- Not defined with applyTypeToArg because you can't print from GHC.Core.+applyTypeToArgs :: CoreExpr -> Type -> [CoreExpr] -> Type+-- ^ A more efficient version of 'applyTypeToArg' when we have several arguments.+-- The first argument is just for debugging, and gives some context+applyTypeToArgs e op_ty args+  = go op_ty args+  where+    go op_ty []                   = op_ty+    go op_ty (Type ty : args)     = go_ty_args op_ty [ty] args+    go op_ty (Coercion co : args) = go_ty_args op_ty [mkCoercionTy co] args+    go op_ty (_ : args)           | Just (_, res_ty) <- splitFunTy_maybe op_ty+                                  = go res_ty args+    go _ _ = pprPanic "applyTypeToArgs" panic_msg++    -- go_ty_args: accumulate type arguments so we can+    -- instantiate all at once with piResultTys+    go_ty_args op_ty rev_tys (Type ty : args)+       = go_ty_args op_ty (ty:rev_tys) args+    go_ty_args op_ty rev_tys (Coercion co : args)+       = go_ty_args op_ty (mkCoercionTy co : rev_tys) args+    go_ty_args op_ty rev_tys args+       = go (piResultTys op_ty (reverse rev_tys)) args++    panic_msg = vcat [ text "Expression:" <+> pprCoreExpr e+                     , text "Type:" <+> ppr op_ty+                     , text "Args:" <+> ppr args ]+++{-+************************************************************************+*                                                                      *+\subsection{Attaching notes}+*                                                                      *+************************************************************************+-}++-- | Wrap the given expression in the coercion safely, dropping+-- identity coercions and coalescing nested coercions+mkCast :: CoreExpr -> CoercionR -> CoreExpr+mkCast e co+  | ASSERT2( coercionRole co == Representational+           , text "coercion" <+> ppr co <+> ptext (sLit "passed to mkCast")+             <+> ppr e <+> text "has wrong role" <+> ppr (coercionRole co) )+    isReflCo co+  = e++mkCast (Coercion e_co) co+  | isCoVarType (coercionRKind co)+       -- The guard here checks that g has a (~#) on both sides,+       -- otherwise decomposeCo fails.  Can in principle happen+       -- with unsafeCoerce+  = Coercion (mkCoCast e_co co)++mkCast (Cast expr co2) co+  = WARN(let { from_ty = coercionLKind co;+               to_ty2  = coercionRKind co2 } in+            not (from_ty `eqType` to_ty2),+             vcat ([ text "expr:" <+> ppr expr+                   , text "co2:" <+> ppr co2+                   , text "co:" <+> ppr co ]) )+    mkCast expr (mkTransCo co2 co)++mkCast (Tick t expr) co+   = Tick t (mkCast expr co)++mkCast expr co+  = let from_ty = coercionLKind co in+    WARN( not (from_ty `eqType` exprType expr),+          text "Trying to coerce" <+> text "(" <> ppr expr+          $$ text "::" <+> ppr (exprType expr) <> text ")"+          $$ ppr co $$ ppr (coercionType co) )+    (Cast expr co)++-- | Wraps the given expression in the source annotation, dropping the+-- annotation if possible.+mkTick :: Tickish Id -> CoreExpr -> CoreExpr+mkTick t orig_expr = mkTick' id id orig_expr+ where+  -- Some ticks (cost-centres) can be split in two, with the+  -- non-counting part having laxer placement properties.+  canSplit = tickishCanSplit t && tickishPlace (mkNoCount t) /= tickishPlace t++  mkTick' :: (CoreExpr -> CoreExpr) -- ^ apply after adding tick (float through)+          -> (CoreExpr -> CoreExpr) -- ^ apply before adding tick (float with)+          -> CoreExpr               -- ^ current expression+          -> CoreExpr+  mkTick' top rest expr = case expr of++    -- Cost centre ticks should never be reordered relative to each+    -- other. Therefore we can stop whenever two collide.+    Tick t2 e+      | ProfNote{} <- t2, ProfNote{} <- t -> top $ Tick t $ rest expr++    -- Otherwise we assume that ticks of different placements float+    -- through each other.+      | tickishPlace t2 /= tickishPlace t -> mkTick' (top . Tick t2) rest e++    -- For annotations this is where we make sure to not introduce+    -- redundant ticks.+      | tickishContains t t2              -> mkTick' top rest e+      | tickishContains t2 t              -> orig_expr+      | otherwise                         -> mkTick' top (rest . Tick t2) e++    -- Ticks don't care about types, so we just float all ticks+    -- through them. Note that it's not enough to check for these+    -- cases top-level. While mkTick will never produce Core with type+    -- expressions below ticks, such constructs can be the result of+    -- unfoldings. We therefore make an effort to put everything into+    -- the right place no matter what we start with.+    Cast e co   -> mkTick' (top . flip Cast co) rest e+    Coercion co -> Coercion co++    Lam x e+      -- Always float through type lambdas. Even for non-type lambdas,+      -- floating is allowed for all but the most strict placement rule.+      | not (isRuntimeVar x) || tickishPlace t /= PlaceRuntime+      -> mkTick' (top . Lam x) rest e++      -- If it is both counting and scoped, we split the tick into its+      -- two components, often allowing us to keep the counting tick on+      -- the outside of the lambda and push the scoped tick inside.+      -- The point of this is that the counting tick can probably be+      -- floated, and the lambda may then be in a position to be+      -- beta-reduced.+      | canSplit+      -> top $ Tick (mkNoScope t) $ rest $ Lam x $ mkTick (mkNoCount t) e++    App f arg+      -- Always float through type applications.+      | not (isRuntimeArg arg)+      -> mkTick' (top . flip App arg) rest f++      -- We can also float through constructor applications, placement+      -- permitting. Again we can split.+      | isSaturatedConApp expr && (tickishPlace t==PlaceCostCentre || canSplit)+      -> if tickishPlace t == PlaceCostCentre+         then top $ rest $ tickHNFArgs t expr+         else top $ Tick (mkNoScope t) $ rest $ tickHNFArgs (mkNoCount t) expr++    Var x+      | notFunction && tickishPlace t == PlaceCostCentre+      -> orig_expr+      | notFunction && canSplit+      -> top $ Tick (mkNoScope t) $ rest expr+      where+        -- SCCs can be eliminated on variables provided the variable+        -- is not a function.  In these cases the SCC makes no difference:+        -- the cost of evaluating the variable will be attributed to its+        -- definition site.  When the variable refers to a function, however,+        -- an SCC annotation on the variable affects the cost-centre stack+        -- when the function is called, so we must retain those.+        notFunction = not (isFunTy (idType x))++    Lit{}+      | tickishPlace t == PlaceCostCentre+      -> orig_expr++    -- Catch-all: Annotate where we stand+    _any -> top $ Tick t $ rest expr++mkTicks :: [Tickish Id] -> CoreExpr -> CoreExpr+mkTicks ticks expr = foldr mkTick expr ticks++isSaturatedConApp :: CoreExpr -> Bool+isSaturatedConApp e = go e []+  where go (App f a) as = go f (a:as)+        go (Var fun) args+           = isConLikeId fun && idArity fun == valArgCount args+        go (Cast f _) as = go f as+        go _ _ = False++mkTickNoHNF :: Tickish Id -> CoreExpr -> CoreExpr+mkTickNoHNF t e+  | exprIsHNF e = tickHNFArgs t e+  | otherwise   = mkTick t e++-- push a tick into the arguments of a HNF (call or constructor app)+tickHNFArgs :: Tickish Id -> CoreExpr -> CoreExpr+tickHNFArgs t e = push t e+ where+  push t (App f (Type u)) = App (push t f) (Type u)+  push t (App f arg) = App (push t f) (mkTick t arg)+  push _t e = e++-- | Strip ticks satisfying a predicate from top of an expression+stripTicksTop :: (Tickish Id -> Bool) -> Expr b -> ([Tickish Id], Expr b)+stripTicksTop p = go []+  where go ts (Tick t e) | p t = go (t:ts) e+        go ts other            = (reverse ts, other)++-- | Strip ticks satisfying a predicate from top of an expression,+-- returning the remaining expression+stripTicksTopE :: (Tickish Id -> Bool) -> Expr b -> Expr b+stripTicksTopE p = go+  where go (Tick t e) | p t = go e+        go other            = other++-- | Strip ticks satisfying a predicate from top of an expression,+-- returning the ticks+stripTicksTopT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]+stripTicksTopT p = go []+  where go ts (Tick t e) | p t = go (t:ts) e+        go ts _                = ts++-- | Completely strip ticks satisfying a predicate from an+-- expression. Note this is O(n) in the size of the expression!+stripTicksE :: (Tickish Id -> Bool) -> Expr b -> Expr b+stripTicksE p expr = go expr+  where go (App e a)        = App (go e) (go a)+        go (Lam b e)        = Lam b (go e)+        go (Let b e)        = Let (go_bs b) (go e)+        go (Case e b t as)  = Case (go e) b t (map go_a as)+        go (Cast e c)       = Cast (go e) c+        go (Tick t e)+          | p t             = go e+          | otherwise       = Tick t (go e)+        go other            = other+        go_bs (NonRec b e)  = NonRec b (go e)+        go_bs (Rec bs)      = Rec (map go_b bs)+        go_b (b, e)         = (b, go e)+        go_a (c,bs,e)       = (c,bs, go e)++stripTicksT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]+stripTicksT p expr = fromOL $ go expr+  where go (App e a)        = go e `appOL` go a+        go (Lam _ e)        = go e+        go (Let b e)        = go_bs b `appOL` go e+        go (Case e _ _ as)  = go e `appOL` concatOL (map go_a as)+        go (Cast e _)       = go e+        go (Tick t e)+          | p t             = t `consOL` go e+          | otherwise       = go e+        go _                = nilOL+        go_bs (NonRec _ e)  = go e+        go_bs (Rec bs)      = concatOL (map go_b bs)+        go_b (_, e)         = go e+        go_a (_, _, e)      = go e++{-+************************************************************************+*                                                                      *+\subsection{Other expression construction}+*                                                                      *+************************************************************************+-}++bindNonRec :: Id -> CoreExpr -> CoreExpr -> CoreExpr+-- ^ @bindNonRec x r b@ produces either:+--+-- > let x = r in b+--+-- or:+--+-- > case r of x { _DEFAULT_ -> b }+--+-- depending on whether we have to use a @case@ or @let@+-- binding for the expression (see 'needsCaseBinding').+-- It's used by the desugarer to avoid building bindings+-- that give Core Lint a heart attack, although actually+-- the simplifier deals with them perfectly well. See+-- also 'GHC.Core.Make.mkCoreLet'+bindNonRec bndr rhs body+  | isTyVar bndr                       = let_bind+  | isCoVar bndr                       = if isCoArg rhs then let_bind+    {- See Note [Binding coercions] -}                  else case_bind+  | isJoinId bndr                      = let_bind+  | needsCaseBinding (idType bndr) rhs = case_bind+  | otherwise                          = let_bind+  where+    case_bind = mkDefaultCase rhs bndr body+    let_bind  = Let (NonRec bndr rhs) body++-- | Tests whether we have to use a @case@ rather than @let@ binding for this expression+-- as per the invariants of 'CoreExpr': see "GHC.Core#let_app_invariant"+needsCaseBinding :: Type -> CoreExpr -> Bool+needsCaseBinding ty rhs = isUnliftedType ty && not (exprOkForSpeculation rhs)+        -- Make a case expression instead of a let+        -- These can arise either from the desugarer,+        -- or from beta reductions: (\x.e) (x +# y)++mkAltExpr :: AltCon     -- ^ Case alternative constructor+          -> [CoreBndr] -- ^ Things bound by the pattern match+          -> [Type]     -- ^ The type arguments to the case alternative+          -> CoreExpr+-- ^ This guy constructs the value that the scrutinee must have+-- given that you are in one particular branch of a case+mkAltExpr (DataAlt con) args inst_tys+  = mkConApp con (map Type inst_tys ++ varsToCoreExprs args)+mkAltExpr (LitAlt lit) [] []+  = Lit lit+mkAltExpr (LitAlt _) _ _ = panic "mkAltExpr LitAlt"+mkAltExpr DEFAULT _ _ = panic "mkAltExpr DEFAULT"++mkDefaultCase :: CoreExpr -> Id -> CoreExpr -> CoreExpr+-- Make (case x of y { DEFAULT -> e }+mkDefaultCase scrut case_bndr body+  = Case scrut case_bndr (exprType body) [(DEFAULT, [], body)]++mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr+-- Use this function if possible, when building a case,+-- because it ensures that the type on the Case itself+-- doesn't mention variables bound by the case+-- See Note [Care with the type of a case expression]+mkSingleAltCase scrut case_bndr con bndrs body+  = Case scrut case_bndr case_ty [(con,bndrs,body)]+  where+    body_ty = exprType body++    case_ty -- See Note [Care with the type of a case expression]+      | Just body_ty' <- occCheckExpand bndrs body_ty+      = body_ty'++      | otherwise+      = pprPanic "mkSingleAltCase" (ppr scrut $$ ppr bndrs $$ ppr body_ty)++{- Note [Care with the type of a case expression]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider a phantom type synonym+   type S a = Int+and we want to form the case expression+   case x of K (a::*) -> (e :: S a)++We must not make the type field of the case-expression (S a) because+'a' isn't in scope.  Hence the call to occCheckExpand.  This caused+issue #17056.++NB: this situation can only arise with type synonyms, which can+falsely "mention" type variables that aren't "really there", and which+can be eliminated by expanding the synonym.++Note [Binding coercions]+~~~~~~~~~~~~~~~~~~~~~~~~+Consider binding a CoVar, c = e.  Then, we must satisfy+Note [Core type and coercion invariant] in GHC.Core,+which allows only (Coercion co) on the RHS.++************************************************************************+*                                                                      *+               Operations oer case alternatives+*                                                                      *+************************************************************************++The default alternative must be first, if it exists at all.+This makes it easy to find, though it makes matching marginally harder.+-}++-- | Extract the default case alternative+findDefault :: [(AltCon, [a], b)] -> ([(AltCon, [a], b)], Maybe b)+findDefault ((DEFAULT,args,rhs) : alts) = ASSERT( null args ) (alts, Just rhs)+findDefault alts                        =                     (alts, Nothing)++addDefault :: [(AltCon, [a], b)] -> Maybe b -> [(AltCon, [a], b)]+addDefault alts Nothing    = alts+addDefault alts (Just rhs) = (DEFAULT, [], rhs) : alts++isDefaultAlt :: (AltCon, a, b) -> Bool+isDefaultAlt (DEFAULT, _, _) = True+isDefaultAlt _               = False++-- | Find the case alternative corresponding to a particular+-- constructor: panics if no such constructor exists+findAlt :: AltCon -> [(AltCon, a, b)] -> Maybe (AltCon, a, b)+    -- A "Nothing" result *is* legitimate+    -- See Note [Unreachable code]+findAlt con alts+  = case alts of+        (deflt@(DEFAULT,_,_):alts) -> go alts (Just deflt)+        _                          -> go alts Nothing+  where+    go []                     deflt = deflt+    go (alt@(con1,_,_) : alts) deflt+      = case con `cmpAltCon` con1 of+          LT -> deflt   -- Missed it already; the alts are in increasing order+          EQ -> Just alt+          GT -> ASSERT( not (con1 == DEFAULT) ) go alts deflt++{- Note [Unreachable code]+~~~~~~~~~~~~~~~~~~~~~~~~~~+It is possible (although unusual) for GHC to find a case expression+that cannot match.  For example:++     data Col = Red | Green | Blue+     x = Red+     f v = case x of+              Red -> ...+              _ -> ...(case x of { Green -> e1; Blue -> e2 })...++Suppose that for some silly reason, x isn't substituted in the case+expression.  (Perhaps there's a NOINLINE on it, or profiling SCC stuff+gets in the way; cf #3118.)  Then the full-laziness pass might produce+this++     x = Red+     lvl = case x of { Green -> e1; Blue -> e2 })+     f v = case x of+             Red -> ...+             _ -> ...lvl...++Now if x gets inlined, we won't be able to find a matching alternative+for 'Red'.  That's because 'lvl' is unreachable.  So rather than crashing+we generate (error "Inaccessible alternative").++Similar things can happen (augmented by GADTs) when the Simplifier+filters down the matching alternatives in Simplify.rebuildCase.+-}++---------------------------------+mergeAlts :: [(AltCon, a, b)] -> [(AltCon, a, b)] -> [(AltCon, a, b)]+-- ^ Merge alternatives preserving order; alternatives in+-- the first argument shadow ones in the second+mergeAlts [] as2 = as2+mergeAlts as1 [] = as1+mergeAlts (a1:as1) (a2:as2)+  = case a1 `cmpAlt` a2 of+        LT -> a1 : mergeAlts as1      (a2:as2)+        EQ -> a1 : mergeAlts as1      as2       -- Discard a2+        GT -> a2 : mergeAlts (a1:as1) as2+++---------------------------------+trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]+-- ^ Given:+--+-- > case (C a b x y) of+-- >        C b x y -> ...+--+-- We want to drop the leading type argument of the scrutinee+-- leaving the arguments to match against the pattern++trimConArgs DEFAULT      args = ASSERT( null args ) []+trimConArgs (LitAlt _)   args = ASSERT( null args ) []+trimConArgs (DataAlt dc) args = dropList (dataConUnivTyVars dc) args++filterAlts :: TyCon                -- ^ Type constructor of scrutinee's type (used to prune possibilities)+           -> [Type]               -- ^ And its type arguments+           -> [AltCon]             -- ^ 'imposs_cons': constructors known to be impossible due to the form of the scrutinee+           -> [(AltCon, [Var], a)] -- ^ Alternatives+           -> ([AltCon], [(AltCon, [Var], a)])+             -- Returns:+             --  1. Constructors that will never be encountered by the+             --     *default* case (if any).  A superset of imposs_cons+             --  2. The new alternatives, trimmed by+             --        a) remove imposs_cons+             --        b) remove constructors which can't match because of GADTs+             --+             -- NB: the final list of alternatives may be empty:+             -- This is a tricky corner case.  If the data type has no constructors,+             -- which GHC allows, or if the imposs_cons covers all constructors (after taking+             -- account of GADTs), then no alternatives can match.+             --+             -- If callers need to preserve the invariant that there is always at least one branch+             -- in a "case" statement then they will need to manually add a dummy case branch that just+             -- calls "error" or similar.+filterAlts _tycon inst_tys imposs_cons alts+  = (imposs_deflt_cons, addDefault trimmed_alts maybe_deflt)+  where+    (alts_wo_default, maybe_deflt) = findDefault alts+    alt_cons = [con | (con,_,_) <- alts_wo_default]++    trimmed_alts = filterOut (impossible_alt inst_tys) alts_wo_default++    imposs_cons_set = Set.fromList imposs_cons+    imposs_deflt_cons =+      imposs_cons ++ filterOut (`Set.member` imposs_cons_set) alt_cons+         -- "imposs_deflt_cons" are handled+         --   EITHER by the context,+         --   OR by a non-DEFAULT branch in this case expression.++    impossible_alt :: [Type] -> (AltCon, a, b) -> Bool+    impossible_alt _ (con, _, _) | con `Set.member` imposs_cons_set = True+    impossible_alt inst_tys (DataAlt con, _, _) = dataConCannotMatch inst_tys con+    impossible_alt _  _                         = False++-- | Refine the default alternative to a 'DataAlt', if there is a unique way to do so.+-- See Note [Refine Default Alts]+refineDefaultAlt :: [Unique]          -- ^ Uniques for constructing new binders+                 -> TyCon             -- ^ Type constructor of scrutinee's type+                 -> [Type]            -- ^ Type arguments of scrutinee's type+                 -> [AltCon]          -- ^ Constructors that cannot match the DEFAULT (if any)+                 -> [CoreAlt]+                 -> (Bool, [CoreAlt]) -- ^ 'True', if a default alt was replaced with a 'DataAlt'+refineDefaultAlt us tycon tys imposs_deflt_cons all_alts+  | (DEFAULT,_,rhs) : rest_alts <- all_alts+  , isAlgTyCon tycon            -- It's a data type, tuple, or unboxed tuples.+  , not (isNewTyCon tycon)      -- We can have a newtype, if we are just doing an eval:+                                --      case x of { DEFAULT -> e }+                                -- and we don't want to fill in a default for them!+  , Just all_cons <- tyConDataCons_maybe tycon+  , let imposs_data_cons = mkUniqSet [con | DataAlt con <- imposs_deflt_cons]+                             -- We now know it's a data type, so we can use+                             -- UniqSet rather than Set (more efficient)+        impossible con   = con `elementOfUniqSet` imposs_data_cons+                             || dataConCannotMatch tys con+  = case filterOut impossible all_cons of+       -- Eliminate the default alternative+       -- altogether if it can't match:+       []    -> (False, rest_alts)++       -- It matches exactly one constructor, so fill it in:+       [con] -> (True, mergeAlts rest_alts [(DataAlt con, ex_tvs ++ arg_ids, rhs)])+                       -- We need the mergeAlts to keep the alternatives in the right order+             where+                (ex_tvs, arg_ids) = dataConRepInstPat us con tys++       -- It matches more than one, so do nothing+       _  -> (False, all_alts)++  | debugIsOn, isAlgTyCon tycon, null (tyConDataCons tycon)+  , not (isFamilyTyCon tycon || isAbstractTyCon tycon)+        -- Check for no data constructors+        -- This can legitimately happen for abstract types and type families,+        -- so don't report that+  = (False, all_alts)++  | otherwise      -- The common case+  = (False, all_alts)++{- Note [Refine Default Alts]++refineDefaultAlt replaces the DEFAULT alt with a constructor if there is one+possible value it could be.++The simplest example being++foo :: () -> ()+foo x = case x of !_ -> ()++rewrites to++foo :: () -> ()+foo x = case x of () -> ()++There are two reasons in general why this is desirable.++1. We can simplify inner expressions++In this example we can eliminate the inner case by refining the outer case.+If we don't refine it, we are left with both case expressions.++```+{-# LANGUAGE BangPatterns #-}+module Test where++mid x = x+{-# NOINLINE mid #-}++data Foo = Foo1 ()++test :: Foo -> ()+test x =+  case x of+    !_ -> mid (case x of+                Foo1 x1 -> x1)++```++refineDefaultAlt fills in the DEFAULT here with `Foo ip1` and then x+becomes bound to `Foo ip1` so is inlined into the other case which+causes the KnownBranch optimisation to kick in.+++2. combineIdenticalAlts does a better job++Simon Jakobi also points out that that combineIdenticalAlts will do a better job+if we refine the DEFAULT first.++```+data D = C0 | C1 | C2++case e of+   DEFAULT -> e0+   C0 -> e1+   C1 -> e1+```++When we apply combineIdenticalAlts to this expression, it can't+combine the alts for C0 and C1, as we already have a default case.++If we apply refineDefaultAlt first, we get++```+case e of+  C0 -> e1+  C1 -> e1+  C2 -> e0+```++and combineIdenticalAlts can turn that into++```+case e of+  DEFAULT -> e1+  C2 -> e0+```++It isn't obvious that refineDefaultAlt does this but if you look at its one+call site in SimplUtils then the `imposs_deflt_cons` argument is populated with+constructors which are matched elsewhere.++-}+++++{- Note [Combine identical alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If several alternatives are identical, merge them into a single+DEFAULT alternative.  I've occasionally seen this making a big+difference:++     case e of               =====>     case e of+       C _ -> f x                         D v -> ....v....+       D v -> ....v....                   DEFAULT -> f x+       DEFAULT -> f x++The point is that we merge common RHSs, at least for the DEFAULT case.+[One could do something more elaborate but I've never seen it needed.]+To avoid an expensive test, we just merge branches equal to the *first*+alternative; this picks up the common cases+     a) all branches equal+     b) some branches equal to the DEFAULT (which occurs first)++The case where Combine Identical Alternatives transformation showed up+was like this (base/Foreign/C/Err/Error.hs):++        x | p `is` 1 -> e1+          | p `is` 2 -> e2+        ...etc...++where @is@ was something like++        p `is` n = p /= (-1) && p == n++This gave rise to a horrible sequence of cases++        case p of+          (-1) -> $j p+          1    -> e1+          DEFAULT -> $j p++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 Simplify.simplAlt may zap the+occurrence info on the binders in the alternatives, which in turn+defeats combineIdenticalAlts (see #7360).++Note [Care with impossible-constructors when combining alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have (#10538)+   data T = A | B | C | D++      case x::T of   (Imposs-default-cons {A,B})+         DEFAULT -> e1+         A -> e2+         B -> e1++When calling combineIdentialAlts, we'll have computed that the+"impossible constructors" for the DEFAULT alt is {A,B}, since if x is+A or B we'll take the other alternatives.  But suppose we combine B+into the DEFAULT, to get++      case x::T of   (Imposs-default-cons {A})+         DEFAULT -> e1+         A -> e2++Then we must be careful to trim the impossible constructors to just {A},+else we risk compiling 'e1' wrong!++Not only that, but we take care when there is no DEFAULT beforehand,+because we are introducing one.  Consider++   case x of   (Imposs-default-cons {A,B,C})+     A -> e1+     B -> e2+     C -> e1++Then when combining the A and C alternatives we get++   case x of   (Imposs-default-cons {B})+     DEFAULT -> e1+     B -> e2++Note that we have a new DEFAULT branch that we didn't have before.  So+we need delete from the "impossible-default-constructors" all the+known-con alternatives that we have eliminated. (In #11172 we+missed the first one.)++-}++combineIdenticalAlts :: [AltCon]    -- Constructors that cannot match DEFAULT+                     -> [CoreAlt]+                     -> (Bool,      -- True <=> something happened+                         [AltCon],  -- New constructors that cannot match DEFAULT+                         [CoreAlt]) -- New alternatives+-- See Note [Combine identical alternatives]+-- True <=> we did some combining, result is a single DEFAULT alternative+combineIdenticalAlts imposs_deflt_cons ((con1,bndrs1,rhs1) : rest_alts)+  | all isDeadBinder bndrs1    -- Remember the default+  , not (null elim_rest) -- alternative comes first+  = (True, imposs_deflt_cons', deflt_alt : filtered_rest)+  where+    (elim_rest, filtered_rest) = partition identical_to_alt1 rest_alts+    deflt_alt = (DEFAULT, [], mkTicks (concat tickss) rhs1)++     -- See Note [Care with impossible-constructors when combining alternatives]+    imposs_deflt_cons' = imposs_deflt_cons `minusList` elim_cons+    elim_cons = elim_con1 ++ map fstOf3 elim_rest+    elim_con1 = case con1 of     -- Don't forget con1!+                  DEFAULT -> []  -- See Note [+                  _       -> [con1]++    cheapEqTicked e1 e2 = cheapEqExpr' tickishFloatable e1 e2+    identical_to_alt1 (_con,bndrs,rhs)+      = all isDeadBinder bndrs && rhs `cheapEqTicked` rhs1+    tickss = map (stripTicksT tickishFloatable . thdOf3) elim_rest++combineIdenticalAlts imposs_cons alts+  = (False, imposs_cons, alts)++{- *********************************************************************+*                                                                      *+             exprIsTrivial+*                                                                      *+************************************************************************++Note [exprIsTrivial]+~~~~~~~~~~~~~~~~~~~~+@exprIsTrivial@ is true of expressions we are unconditionally happy to+                duplicate; simple variables and constants, and type+                applications.  Note that primop Ids aren't considered+                trivial unless++Note [Variables are trivial]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There used to be a gruesome test for (hasNoBinding v) in the+Var case:+        exprIsTrivial (Var v) | hasNoBinding v = idArity v == 0+The idea here is that a constructor worker, like \$wJust, is+really short for (\x -> \$wJust x), because \$wJust has no binding.+So it should be treated like a lambda.  Ditto unsaturated primops.+But now constructor workers are not "have-no-binding" Ids.  And+completely un-applied primops and foreign-call Ids are sufficiently+rare that I plan to allow them to be duplicated and put up with+saturating them.++Note [Tick trivial]+~~~~~~~~~~~~~~~~~~~+Ticks are only trivial if they are pure annotations. If we treat+"tick<n> x" as trivial, it will be inlined inside lambdas and the+entry count will be skewed, for example.  Furthermore "scc<n> x" will+turn into just "x" in mkTick.++Note [Empty case is trivial]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The expression (case (x::Int) Bool of {}) is just a type-changing+case used when we are sure that 'x' will not return.  See+Note [Empty case alternatives] in GHC.Core.++If the scrutinee is trivial, then so is the whole expression; and the+CoreToSTG pass in fact drops the case expression leaving only the+scrutinee.++Having more trivial expressions is good.  Moreover, if we don't treat+it as trivial we may land up with let-bindings like+   let v = case x of {} in ...+and after CoreToSTG that gives+   let v = x in ...+and that confuses the code generator (#11155). So best to kill+it off at source.+-}++exprIsTrivial :: CoreExpr -> Bool+-- If you modify this function, you may also+-- need to modify getIdFromTrivialExpr+exprIsTrivial (Var _)          = True        -- See Note [Variables are trivial]+exprIsTrivial (Type _)         = True+exprIsTrivial (Coercion _)     = True+exprIsTrivial (Lit lit)        = litIsTrivial lit+exprIsTrivial (App e arg)      = not (isRuntimeArg arg) && exprIsTrivial e+exprIsTrivial (Lam b e)        = not (isRuntimeVar b) && exprIsTrivial e+exprIsTrivial (Tick t e)       = not (tickishIsCode t) && exprIsTrivial e+                                 -- See Note [Tick trivial]+exprIsTrivial (Cast e _)       = exprIsTrivial e+exprIsTrivial (Case e _ _ [])  = exprIsTrivial e  -- See Note [Empty case is trivial]+exprIsTrivial _                = False++{-+Note [getIdFromTrivialExpr]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+When substituting in a breakpoint we need to strip away the type cruft+from a trivial expression and get back to the Id.  The invariant is+that the expression we're substituting was originally trivial+according to exprIsTrivial, AND the expression is not a literal.+See Note [substTickish] for how breakpoint substitution preserves+this extra invariant.++We also need this functionality in CorePrep to extract out Id of a+function which we are saturating.  However, in this case we don't know+if the variable actually refers to a literal; thus we use+'getIdFromTrivialExpr_maybe' to handle this case.  See test+T12076lit for an example where this matters.+-}++getIdFromTrivialExpr :: HasDebugCallStack => CoreExpr -> Id+getIdFromTrivialExpr e+    = fromMaybe (pprPanic "getIdFromTrivialExpr" (ppr e))+                (getIdFromTrivialExpr_maybe e)++getIdFromTrivialExpr_maybe :: CoreExpr -> Maybe Id+-- See Note [getIdFromTrivialExpr]+-- Th equations for this should line up with those for exprIsTrivial+getIdFromTrivialExpr_maybe e+  = go e+  where+    go (App f t) | not (isRuntimeArg t)   = go f+    go (Tick t e) | not (tickishIsCode t) = go e+    go (Cast e _)                         = go e+    go (Lam b e) | not (isRuntimeVar b)   = go e+    go (Case e _ _ [])                    = go e+    go (Var v) = Just v+    go _       = Nothing++{-+exprIsBottom is a very cheap and cheerful function; it may return+False for bottoming expressions, but it never costs much to ask.  See+also GHC.Core.Arity.exprBotStrictness_maybe, but that's a bit more+expensive.+-}++exprIsBottom :: CoreExpr -> Bool+-- See Note [Bottoming expressions]+exprIsBottom e+  | isEmptyTy (exprType e)+  = True+  | otherwise+  = go 0 e+  where+    go n (Var v) = isBottomingId v &&  n >= idArity v+    go n (App e a) | isTypeArg a = go n e+                   | otherwise   = go (n+1) e+    go n (Tick _ e)              = go n e+    go n (Cast e _)              = go n e+    go n (Let _ e)               = go n e+    go n (Lam v e) | isTyVar v   = go n e+    go _ (Case _ _ _ alts)       = null alts+       -- See Note [Empty case alternatives] in GHC.Core+    go _ _                       = False++{- Note [Bottoming expressions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A bottoming expression is guaranteed to diverge, or raise an+exception.  We can test for it in two different ways, and exprIsBottom+checks for both of these situations:++* Visibly-bottom computations.  For example+      (error Int "Hello")+  is visibly bottom.  The strictness analyser also finds out if+  a function diverges or raises an exception, and puts that info+  in its strictness signature.++* Empty types.  If a type is empty, its only inhabitant is bottom.+  For example:+      data T+      f :: T -> Bool+      f = \(x:t). case x of Bool {}+  Since T has no data constructors, the case alternatives are of course+  empty.  However note that 'x' is not bound to a visibly-bottom value;+  it's the *type* that tells us it's going to diverge.++A GADT may also be empty even though it has constructors:+        data T a where+          T1 :: a -> T Bool+          T2 :: T Int+        ...(case (x::T Char) of {})...+Here (T Char) is uninhabited.  A more realistic case is (Int ~ Bool),+which is likewise uninhabited.+++************************************************************************+*                                                                      *+             exprIsDupable+*                                                                      *+************************************************************************++Note [exprIsDupable]+~~~~~~~~~~~~~~~~~~~~+@exprIsDupable@ is true of expressions that can be duplicated at a modest+                cost in code size.  This will only happen in different case+                branches, so there's no issue about duplicating work.++                That is, exprIsDupable returns True of (f x) even if+                f is very very expensive to call.++                Its only purpose is to avoid fruitless let-binding+                and then inlining of case join points+-}++exprIsDupable :: DynFlags -> CoreExpr -> Bool+exprIsDupable dflags e+  = isJust (go dupAppSize e)+  where+    go :: Int -> CoreExpr -> Maybe Int+    go n (Type {})     = Just n+    go n (Coercion {}) = Just n+    go n (Var {})      = decrement n+    go n (Tick _ e)    = go n e+    go n (Cast e _)    = go n e+    go n (App f a) | Just n' <- go n a = go n' f+    go n (Lit lit) | litIsDupable dflags lit = decrement n+    go _ _ = Nothing++    decrement :: Int -> Maybe Int+    decrement 0 = Nothing+    decrement n = Just (n-1)++dupAppSize :: Int+dupAppSize = 8   -- Size of term we are prepared to duplicate+                 -- This is *just* big enough to make test MethSharing+                 -- inline enough join points.  Really it should be+                 -- smaller, and could be if we fixed #4960.++{-+************************************************************************+*                                                                      *+             exprIsCheap, exprIsExpandable+*                                                                      *+************************************************************************++Note [exprIsWorkFree]+~~~~~~~~~~~~~~~~~~~~~+exprIsWorkFree is used when deciding whether to inline something; we+don't inline it if doing so might duplicate work, by peeling off a+complete copy of the expression.  Here we do not want even to+duplicate a primop (#5623):+   eg   let x = a #+ b in x +# x+   we do not want to inline/duplicate x++Previously we were a bit more liberal, which led to the primop-duplicating+problem.  However, being more conservative did lead to a big regression in+one nofib benchmark, wheel-sieve1.  The situation looks like this:++   let noFactor_sZ3 :: GHC.Types.Int -> GHC.Types.Bool+       noFactor_sZ3 = case s_adJ of _ { GHC.Types.I# x_aRs ->+         case GHC.Prim.<=# x_aRs 2 of _ {+           GHC.Types.False -> notDivBy ps_adM qs_adN;+           GHC.Types.True -> lvl_r2Eb }}+       go = \x. ...(noFactor (I# y))....(go x')...++The function 'noFactor' is heap-allocated and then called.  Turns out+that 'notDivBy' is strict in its THIRD arg, but that is invisible to+the caller of noFactor, which therefore cannot do w/w and+heap-allocates noFactor's argument.  At the moment (May 12) we are just+going to put up with this, because the previous more aggressive inlining+(which treated 'noFactor' as work-free) was duplicating primops, which+in turn was making inner loops of array calculations runs slow (#5623)++Note [Case expressions are work-free]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Are case-expressions work-free?  Consider+    let v = case x of (p,q) -> p+        go = \y -> ...case v of ...+Should we inline 'v' at its use site inside the loop?  At the moment+we do.  I experimented with saying that case are *not* work-free, but+that increased allocation slightly.  It's a fairly small effect, and at+the moment we go for the slightly more aggressive version which treats+(case x of ....) as work-free if the alternatives are.++Moreover it improves arities of overloaded functions where+there is only dictionary selection (no construction) involved++Note [exprIsCheap]+~~~~~~~~~~~~~~~~~~++See also Note [Interaction of exprIsCheap and lone variables] in GHC.Core.Unfold++@exprIsCheap@ looks at a Core expression and returns \tr{True} if+it is obviously in weak head normal form, or is cheap to get to WHNF.+[Note that that's not the same as exprIsDupable; an expression might be+big, and hence not dupable, but still cheap.]++By ``cheap'' we mean a computation we're willing to:+        push inside a lambda, or+        inline at more than one place+That might mean it gets evaluated more than once, instead of being+shared.  The main examples of things which aren't WHNF but are+``cheap'' are:++  *     case e of+          pi -> ei+        (where e, and all the ei are cheap)++  *     let x = e in b+        (where e and b are cheap)++  *     op x1 ... xn+        (where op is a cheap primitive operator)++  *     error "foo"+        (because we are happy to substitute it inside a lambda)++Notice that a variable is considered 'cheap': we can push it inside a lambda,+because sharing will make sure it is only evaluated once.++Note [exprIsCheap and exprIsHNF]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Note that exprIsHNF does not imply exprIsCheap.  Eg+        let x = fac 20 in Just x+This responds True to exprIsHNF (you can discard a seq), but+False to exprIsCheap.++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 = blah in f x+should behave equivalently to+   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+-}++--------------------+exprIsWorkFree :: CoreExpr -> Bool   -- See Note [exprIsWorkFree]+exprIsWorkFree = exprIsCheapX isWorkFreeApp++exprIsCheap :: CoreExpr -> Bool+exprIsCheap = exprIsCheapX isCheapApp++exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool+exprIsCheapX ok_app e+  = ok e+  where+    ok e = go 0 e++    -- n is the number of value arguments+    go n (Var v)                      = ok_app v n+    go _ (Lit {})                     = True+    go _ (Type {})                    = True+    go _ (Coercion {})                = True+    go n (Cast e _)                   = go n e+    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 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, Let: see Note [Arguments and let-bindings exprIsCheapX]+++{- Note [exprIsExpandable]+~~~~~~~~~~~~~~~~~~~~~~~~~~+An expression is "expandable" if we are willing to duplicate it, if doing+so might make a RULE or case-of-constructor fire.  Consider+   let x = (a,b)+       y = build g+   in ....(case x of (p,q) -> rhs)....(foldr k z y)....++We don't inline 'x' or 'y' (see Note [Lone variables] in GHC.Core.Unfold),+but we do want++ * the case-expression to simplify+   (via exprIsConApp_maybe, exprIsLiteral_maybe)++ * the foldr/build RULE to fire+   (by expanding the unfolding during rule matching)++So we classify the unfolding of a let-binding as "expandable" (via the+uf_expandable field) if we want to do this kind of on-the-fly+expansion.  Specifically:++* True of constructor applications (K a b)++* True of applications of a "CONLIKE" Id; see Note [CONLIKE pragma] in BasicTypes.+  (NB: exprIsCheap might not be true of this)++* False of case-expressions.  If we have+    let x = case ... in ...(case x of ...)...+  we won't simplify.  We have to inline x.  See #14688.++* False of let-expressions (same reason); and in any case we+  float lets out of an RHS if doing so will reveal an expandable+  application (see SimplEnv.doFloatFromRhs).++* Take care: exprIsExpandable should /not/ be true of primops.  I+  found this in test T5623a:+    let q = /\a. Ptr a (a +# b)+    in case q @ Float of Ptr v -> ...q...++  q's inlining should not be expandable, else exprIsConApp_maybe will+  say that (q @ Float) expands to (Ptr a (a +# b)), and that will+  duplicate the (a +# b) primop, which we should not do lightly.+  (It's quite hard to trigger this bug, but T13155 does so for GHC 8.0.)+-}++-------------------------------------+exprIsExpandable :: CoreExpr -> Bool+-- See Note [exprIsExpandable]+exprIsExpandable e+  = ok e+  where+    ok e = go 0 e++    -- n is the number of value arguments+    go n (Var v)                      = isExpandableApp v n+    go _ (Lit {})                     = True+    go _ (Type {})                    = True+    go _ (Coercion {})                = True+    go n (Cast e _)                   = go n e+    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 _ (Case {})                    = False+    go _ (Let {})                     = False+++-------------------------------------+type CheapAppFun = Id -> Arity -> Bool+  -- Is an application of this function to n *value* args+  -- always cheap, assuming the arguments are cheap?+  -- True mainly of data constructors, partial applications;+  -- but with minor variations:+  --    isWorkFreeApp+  --    isCheapApp+  --    isExpandableApp++isWorkFreeApp :: CheapAppFun+isWorkFreeApp 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+      _                -> False++isCheapApp :: CheapAppFun+isCheapApp fn n_val_args+  | isWorkFreeApp fn n_val_args = True+  | isBottomingId fn            = True  -- See Note [isCheapApp: bottoming functions]+  | otherwise+  = case idDetails fn of+      DataConWorkId {} -> True  -- Actually handled by isWorkFreeApp+      RecSelId {}      -> n_val_args == 1  -- See Note [Record selection]+      ClassOpId {}     -> n_val_args == 1+      PrimOpId op      -> primOpIsCheap op+      _                -> False+        -- In principle we should worry about primops+        -- that return a type variable, since the result+        -- might be applied to something, but I'm not going+        -- to bother to check the number of args++isExpandableApp :: CheapAppFun+isExpandableApp fn n_val_args+  | isWorkFreeApp fn n_val_args = True+  | otherwise+  = case idDetails fn of+      DataConWorkId {} -> True  -- Actually handled by isWorkFreeApp+      RecSelId {}      -> n_val_args == 1  -- See Note [Record selection]+      ClassOpId {}     -> n_val_args == 1+      PrimOpId {}      -> False+      _ | 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]+     all_args_are_preds = all_pred_args n_val_args (idType fn)++     all_pred_args n_val_args ty+       | n_val_args == 0+       = True++       | Just (bndr, ty) <- splitPiTy_maybe ty+       = case bndr of+           Named {}        -> all_pred_args n_val_args ty+           Anon InvisArg _ -> all_pred_args (n_val_args-1) ty+           Anon VisArg _   -> False++       | otherwise+       = False++{- 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+lambda.  Particularly for dictionary field selection.++BUT: Take care with (sel d x)!  The (sel d) might be cheap, but+there's no guarantee that (sel d x) will be too.  Hence (n_val_args == 1)++Note [Expandable overloadings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose the user wrote this+   {-# RULE  forall x. foo (negate x) = h x #-}+   f x = ....(foo (negate x))....+He'd expect the rule to fire. But since negate is overloaded, we might+get this:+    f = \d -> let n = negate d in \x -> ...foo (n x)...+So we treat the application of a function (negate in this case) to a+*dictionary* as expandable.  In effect, every function is CONLIKE when+it's applied only to dictionaries.+++************************************************************************+*                                                                      *+             exprOkForSpeculation+*                                                                      *+************************************************************************+-}++-----------------------------+-- | 'exprOkForSpeculation' returns True of an expression that is:+--+--  * Safe to evaluate even if normal order eval might not+--    evaluate the expression at all, or+--+--  * Safe /not/ to evaluate even if normal order would do so+--+-- It is usually called on arguments of unlifted type, but not always+-- In particular, Simplify.rebuildCase calls it on lifted types+-- when a 'case' is a plain 'seq'. See the example in+-- Note [exprOkForSpeculation: case expressions] below+--+-- Precisely, it returns @True@ iff:+--  a) The expression guarantees to terminate,+--  b) soon,+--  c) without causing a write side effect (e.g. writing a mutable variable)+--  d) without throwing a Haskell exception+--  e) without risking an unchecked runtime exception (array out of bounds,+--     divide by zero)+--+-- For @exprOkForSideEffects@ the list is the same, but omitting (e).+--+-- Note that+--    exprIsHNF            implies exprOkForSpeculation+--    exprOkForSpeculation implies exprOkForSideEffects+--+-- See Note [PrimOp can_fail and has_side_effects] in PrimOp+-- and Note [Transformations affected by can_fail and has_side_effects]+--+-- As an example of the considerations in this test, consider:+--+-- > let x = case y# +# 1# of { r# -> I# r# }+-- > in E+--+-- being translated to:+--+-- > case y# +# 1# of { r# ->+-- >    let x = I# r#+-- >    in E+-- > }+--+-- 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++expr_ok :: (PrimOp -> Bool) -> CoreExpr -> Bool+expr_ok _ (Lit _)      = True+expr_ok _ (Type _)     = True+expr_ok _ (Coercion _) = True++expr_ok primop_ok (Var v)    = app_ok primop_ok v []+expr_ok primop_ok (Cast e _) = expr_ok primop_ok e+expr_ok primop_ok (Lam b e)+                 | isTyVar b = expr_ok primop_ok  e+                 | otherwise = True++-- Tick annotations that *tick* cannot be speculated, because these+-- are meant to identify whether or not (and how often) the particular+-- source expression was evaluated at runtime.+expr_ok primop_ok (Tick tickish e)+   | tickishCounts tickish = False+   | otherwise             = expr_ok primop_ok e++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++expr_ok primop_ok other_expr+  | (expr, args) <- collectArgs other_expr+  = case stripTicksTopE (not . tickishCounts) expr of+        Var f   -> app_ok primop_ok f args+        -- 'LitRubbish' is the only literal that can occur in the head of an+        -- application and will not be matched by the above case (Var /= Lit).+        Lit lit -> ASSERT( lit == rubbishLit ) True+        _       -> False++-----------------------------+app_ok :: (PrimOp -> Bool) -> Id -> [CoreExpr] -> Bool+app_ok primop_ok fun args+  = case idDetails fun of+      DFunId new_type ->  not new_type+         -- DFuns terminate, unless the dict is implemented+         -- with a newtype in which case they may not++      DataConWorkId {} -> True+                -- The strictness of the constructor has already+                -- been expressed by its "wrapper", so we don't need+                -- to take the arguments into account++      PrimOpId op+        | isDivOp op+        , [arg1, Lit lit] <- args+        -> not (isZeroLit lit) && expr_ok primop_ok arg1+              -- Special case for dividing operations that fail+              -- In general they are NOT ok-for-speculation+              -- (which primop_ok will catch), but they ARE OK+              -- if the divisor is definitely non-zero.+              -- Often there is a literal divisor, and this+              -- can get rid of a thunk in an inner loop++        | SeqOp <- op  -- See Note [exprOkForSpeculation and SeqOp/DataToTagOp]+        -> False       --     for the special cases for SeqOp and DataToTagOp+        | DataToTagOp <- op+        -> False++        | otherwise+        -> primop_ok op  -- Check the primop itself+        && and (zipWith primop_arg_ok arg_tys args)  -- Check the arguments++      _other -> isUnliftedType (idType fun)          -- c.f. the Var case of exprIsHNF+             || idArity fun > n_val_args             -- Partial apps+             -- NB: even in the nullary case, do /not/ check+             --     for evaluated-ness of the fun;+             --     see Note [exprOkForSpeculation and evaluated variables]+             where+               n_val_args = valArgCount args+  where+    (arg_tys, _) = splitPiTys (idType fun)++    primop_arg_ok :: TyBinder -> CoreExpr -> Bool+    primop_arg_ok (Named _) _ = True   -- A type argument+    primop_arg_ok (Anon _ ty) arg      -- A term argument+       | isUnliftedType ty = expr_ok primop_ok arg+       | otherwise         = True  -- See Note [Primops with lifted arguments]++-----------------------------+altsAreExhaustive :: [Alt b] -> Bool+-- True  <=> the case alternatives are definitely exhaustive+-- False <=> they may or may not be+altsAreExhaustive []+  = False    -- Should not happen+altsAreExhaustive ((con1,_,_) : alts)+  = case con1 of+      DEFAULT   -> True+      LitAlt {} -> False+      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+      -- enough to deserve special treatment++-- | True of dyadic operators that can fail only if the second arg is zero!+isDivOp :: PrimOp -> Bool+-- This function probably belongs in PrimOp, or even in+-- an automagically generated file.. but it's such a+-- special case I thought I'd leave it here for now.+isDivOp IntQuotOp        = True+isDivOp IntRemOp         = True+isDivOp WordQuotOp       = True+isDivOp WordRemOp        = True+isDivOp FloatDivOp       = True+isDivOp DoubleDivOp      = True+isDivOp _                = False++{- 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 { DEFAULT -> 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.++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. for example,+  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+  evaluate 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: #15696: --------+  Previously SetLevels used exprOkForSpeculation to guide+  floating of single-alternative cases; it now uses exprIsHNF+  Note [Floating single-alternative cases].++  But in those days, consider+    case e of x { DEAFULT ->+      ...(case x of y+            A -> ...+            _ -> ...(case (case x of { B -> p; C -> p }) of+                       I# r -> blah)...+  If SetLevels considers the inner nested case as+  ok-for-speculation it can do case-floating (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 #5453.++----- Historical note: #3717: --------+    foo :: Int -> Int+    foo 0 = 0+    foo n = (if n < 5 then 1 else 2) `seq` foo (n-1)++In earlier GHCs, we got this:+    T.$wfoo =+      \ (ww :: GHC.Prim.Int#) ->+        case ww of ds {+          __DEFAULT -> case (case <# ds 5 of _ {+                          GHC.Types.False -> lvl1;+                          GHC.Types.True -> lvl})+                       of _ { __DEFAULT ->+                       T.$wfoo (GHC.Prim.-# ds_XkE 1) };+          0 -> 0 }++Before join-points etc we could only get rid of two cases (which are+redundant) by recognising that the (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]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Is this ok-for-speculation (see #13027)?+   reallyUnsafePtrEq# a b+Well, yes.  The primop accepts lifted arguments and does not+evaluate them.  Indeed, in general primops are, well, primitive+and do not perform evaluation.++Bottom line:+  * In exprOkForSpeculation we simply ignore all lifted arguments.+  * In the rare case of primops that /do/ evaluate their arguments,+    (namely DataToTagOp and SeqOp) return False; see+    Note [exprOkForSpeculation and evaluated variables]++Note [exprOkForSpeculation and SeqOp/DataToTagOp]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Most primops with lifted arguments don't evaluate them+(see Note [Primops with lifted arguments]), so we can ignore+that argument entirely when doing exprOkForSpeculation.++But DataToTagOp and SeqOp are exceptions to that rule.+For reasons described in Note [exprOkForSpeculation and+evaluated variables], we simply return False for them.++Not doing this made #5129 go bad.+Lots of discussion in #15696.++Note [exprOkForSpeculation and evaluated variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Recall that+  seq#       :: forall a s. a -> State# s -> (# State# s, a #)+  dataToTag# :: forall a.   a -> Int#+must always evaluate their first argument.++Now consider these examples:+ * case x of y { DEFAULT -> ....y.... }+   Should 'y' (alone) be considered ok-for-speculation?++ * case x of y { DEFAULT -> ....f (dataToTag# y)... }+   Should (dataToTag# y) be considered ok-for-spec?++You could argue 'yes', because in the case alternative we know that+'y' is evaluated.  But the binder-swap transformation, which is+extremely useful for float-out, changes these expressions to+   case x of y { DEFAULT -> ....x.... }+   case x of y { DEFAULT -> ....f (dataToTag# x)... }++And now the expression does not obey the let/app invariant!  Yikes!+Moreover we really might float (f (dataToTag# x)) outside the case,+and then it really, really doesn't obey the let/app invariant.++The solution is simple: exprOkForSpeculation does not try to take+advantage of the evaluated-ness of (lifted) variables.  And it returns+False (always) for DataToTagOp and SeqOp.++Note that exprIsHNF /can/ and does take advantage of evaluated-ness;+it doesn't have the trickiness of the let/app invariant to worry about.++************************************************************************+*                                                                      *+             exprIsHNF, exprIsConLike+*                                                                      *+************************************************************************+-}++-- Note [exprIsHNF]             See also Note [exprIsCheap and exprIsHNF]+-- ~~~~~~~~~~~~~~~~+-- | exprIsHNF returns true for expressions that are certainly /already/+-- evaluated to /head/ normal form.  This is used to decide whether it's ok+-- to change:+--+-- > case x of _ -> e+--+--    into:+--+-- > e+--+-- and to decide whether it's safe to discard a 'seq'.+--+-- So, it does /not/ treat variables as evaluated, unless they say they are.+-- However, it /does/ treat partial applications and constructor applications+-- as values, even if their arguments are non-trivial, provided the argument+-- type is lifted. For example, both of these are values:+--+-- > (:) (f x) (map f xs)+-- > map (...redex...)+--+-- because 'seq' on such things completes immediately.+--+-- For unlifted argument types, we have to be careful:+--+-- > C (f x :: Int#)+--+-- Suppose @f x@ diverges; then @C (f x)@ is not a value. However this can't+-- happen: see "GHC.Core#let_app_invariant". This invariant states that arguments of+-- unboxed type must be ok-for-speculation (or trivial).+exprIsHNF :: CoreExpr -> Bool           -- True => Value-lambda, constructor, PAP+exprIsHNF = exprIsHNFlike isDataConWorkId isEvaldUnfolding++-- | Similar to 'exprIsHNF' but includes CONLIKE functions as well as+-- data constructors. Conlike arguments are considered interesting by the+-- inliner.+exprIsConLike :: CoreExpr -> Bool       -- True => lambda, conlike, PAP+exprIsConLike = exprIsHNFlike isConLikeId isConLikeUnfolding++-- | Returns true for values or value-like expressions. These are lambdas,+-- constructors / CONLIKE functions (as determined by the function argument)+-- or PAPs.+--+exprIsHNFlike :: (Var -> Bool) -> (Unfolding -> Bool) -> CoreExpr -> Bool+exprIsHNFlike is_con is_con_unf = is_hnf_like+  where+    is_hnf_like (Var v) -- NB: There are no value args at this point+      =  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+        --   or to a guaranteed-evaluated variable (isEvaldUnfolding)+        --   Contrast with Note [exprOkForSpeculation and evaluated variables]+        -- We don't look through loop breakers here, which is a bit conservative+        -- but otherwise I worry that if an Id's unfolding is just itself,+        -- we could get an infinite loop++    is_hnf_like (Lit _)          = True+    is_hnf_like (Type _)         = True       -- Types are honorary Values;+                                              -- we don't mind copying them+    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+                                      -- See Note [exprIsHNF Tick]+    is_hnf_like (Cast e _)       = is_hnf_like e+    is_hnf_like (App e a)+      | isValArg a               = app_is_value e 1+      | otherwise                = is_hnf_like e+    is_hnf_like (Let _ e)        = is_hnf_like e  -- Lazy let(rec)s don't affect us+    is_hnf_like _                = False++    -- 'n' is the number of value args to which the expression is applied+    -- And n>0: there is at least one value argument+    app_is_value :: CoreExpr -> Int -> Bool+    app_is_value (Var f)    nva = id_app_is_value f nva+    app_is_value (Tick _ f) nva = app_is_value f nva+    app_is_value (Cast f _) nva = app_is_value f nva+    app_is_value (App f a)  nva+      | isValArg a              = app_is_value f (nva + 1)+      | otherwise               = app_is_value f nva+    app_is_value _          _   = False++    id_app_is_value id n_val_args+       = is_con id+       || idArity id > n_val_args+       || id `hasKey` absentErrorIdKey  -- See Note [aBSENT_ERROR_ID] in GHC.Core.Make+                      -- absentError behaves like an honorary data constructor+++{-+Note [exprIsHNF Tick]++We can discard source annotations on HNFs as long as they aren't+tick-like:++  scc c (\x . e)    =>  \x . e+  scc c (C x1..xn)  =>  C x1..xn++So we regard these as HNFs.  Tick annotations that tick are not+regarded as HNF if the expression they surround is HNF, because the+tick is there to tell us that the expression was evaluated, so we+don't want to discard a seq on it.+-}++-- | Can we bind this 'CoreExpr' at the top level?+exprIsTopLevelBindable :: CoreExpr -> Type -> Bool+-- See Note [Core top-level string literals]+-- Precondition: exprType expr = ty+-- Top-level literal strings can't even be wrapped in ticks+--   see Note [Core top-level string literals] in GHC.Core+exprIsTopLevelBindable expr ty+  = not (mightBeUnliftedType ty)+    -- Note that 'expr' may be levity polymorphic here consequently we must use+    -- 'mightBeUnliftedType' rather than 'isUnliftedType' as the latter would panic.+  || exprIsTickedString expr++-- | Check if the expression is zero or more Ticks wrapped around a literal+-- string.+exprIsTickedString :: CoreExpr -> Bool+exprIsTickedString = isJust . exprIsTickedString_maybe++-- | Extract a literal string from an expression that is zero or more Ticks+-- wrapped around a literal string. Returns Nothing if the expression has a+-- different shape.+-- Used to "look through" Ticks in places that need to handle literal strings.+exprIsTickedString_maybe :: CoreExpr -> Maybe ByteString+exprIsTickedString_maybe (Lit (LitString bs)) = Just bs+exprIsTickedString_maybe (Tick t e)+  -- we don't tick literals with CostCentre ticks, compare to mkTick+  | tickishPlace t == PlaceCostCentre = Nothing+  | otherwise = exprIsTickedString_maybe e+exprIsTickedString_maybe _ = Nothing++{-+************************************************************************+*                                                                      *+             Instantiating data constructors+*                                                                      *+************************************************************************++These InstPat functions go here to avoid circularity between DataCon and Id+-}++dataConRepInstPat   ::                 [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])+dataConRepFSInstPat :: [FastString] -> [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])++dataConRepInstPat   = dataConInstPat (repeat ((fsLit "ipv")))+dataConRepFSInstPat = dataConInstPat++dataConInstPat :: [FastString]          -- A long enough list of FSs to use for names+               -> [Unique]              -- An equally long list of uniques, at least one for each binder+               -> DataCon+               -> [Type]                -- Types to instantiate the universally quantified tyvars+               -> ([TyCoVar], [Id])     -- Return instantiated variables+-- dataConInstPat arg_fun fss us con inst_tys returns a tuple+-- (ex_tvs, arg_ids),+--+--   ex_tvs are intended to be used as binders for existential type args+--+--   arg_ids are indended to be used as binders for value arguments,+--     and their types have been instantiated with inst_tys and ex_tys+--     The arg_ids include both evidence and+--     programmer-specified arguments (both after rep-ing)+--+-- Example.+--  The following constructor T1+--+--  data T a where+--    T1 :: forall b. Int -> b -> T(a,b)+--    ...+--+--  has representation type+--   forall a. forall a1. forall b. (a ~ (a1,b)) =>+--     Int -> b -> T a+--+--  dataConInstPat fss us T1 (a1',b') will return+--+--  ([a1'', b''], [c :: (a1', b')~(a1'', b''), x :: Int, y :: b''])+--+--  where the double-primed variables are created with the FastStrings and+--  Uniques given as fss and us+dataConInstPat fss uniqs con inst_tys+  = ASSERT( univ_tvs `equalLength` inst_tys )+    (ex_bndrs, arg_ids)+  where+    univ_tvs = dataConUnivTyVars con+    ex_tvs   = dataConExTyCoVars con+    arg_tys  = dataConRepArgTys con+    arg_strs = dataConRepStrictness con  -- 1-1 with arg_tys+    n_ex = length ex_tvs++      -- split the Uniques and FastStrings+    (ex_uniqs, id_uniqs) = splitAt n_ex uniqs+    (ex_fss,   id_fss)   = splitAt n_ex fss++      -- Make the instantiating substitution for universals+    univ_subst = zipTvSubst univ_tvs inst_tys++      -- Make existential type variables, applying and extending the substitution+    (full_subst, ex_bndrs) = mapAccumL mk_ex_var univ_subst+                                       (zip3 ex_tvs ex_fss ex_uniqs)++    mk_ex_var :: TCvSubst -> (TyCoVar, FastString, Unique) -> (TCvSubst, TyCoVar)+    mk_ex_var subst (tv, fs, uniq) = (Type.extendTCvSubstWithClone subst tv+                                       new_tv+                                     , new_tv)+      where+        new_tv | isTyVar tv+               = mkTyVar (mkSysTvName uniq fs) kind+               | otherwise+               = mkCoVar (mkSystemVarName uniq fs) kind+        kind   = Type.substTyUnchecked subst (varType tv)++      -- Make value vars, instantiating types+    arg_ids = zipWith4 mk_id_var id_uniqs id_fss arg_tys arg_strs+    mk_id_var uniq fs ty str+      = setCaseBndrEvald str $  -- See Note [Mark evaluated arguments]+        mkLocalIdOrCoVar name (Type.substTy full_subst ty)+      where+        name = mkInternalName uniq (mkVarOccFS fs) noSrcSpan++{-+Note [Mark evaluated arguments]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When pattern matching on a constructor with strict fields, the binder+can have an 'evaldUnfolding'.  Moreover, it *should* have one, so that+when loading an interface file unfolding like:+  data T = MkT !Int+  f x = case x of { MkT y -> let v::Int# = case y of I# n -> n+1+                             in ... }+we don't want Lint to complain.  The 'y' is evaluated, so the+case in the RHS of the binding for 'v' is fine.  But only if we+*know* that 'y' is evaluated.++c.f. add_evals in Simplify.simplAlt++************************************************************************+*                                                                      *+         Equality+*                                                                      *+************************************************************************+-}++-- | A cheap equality test which bales out fast!+--      If it returns @True@ the arguments are definitely equal,+--      otherwise, they may or may not be equal.+--+-- See also 'exprIsBig'+cheapEqExpr :: Expr b -> Expr b -> Bool+cheapEqExpr = cheapEqExpr' (const False)++-- | Cheap expression equality test, can ignore ticks by type.+cheapEqExpr' :: (Tickish Id -> Bool) -> Expr b -> Expr b -> Bool+cheapEqExpr' ignoreTick = go_s+  where go_s = go `on` stripTicksTopE ignoreTick+        go (Var v1)   (Var v2)   = v1 == v2+        go (Lit lit1) (Lit lit2) = lit1 == lit2+        go (Type t1)  (Type t2)  = t1 `eqType` t2+        go (Coercion c1) (Coercion c2) = c1 `eqCoercion` c2++        go (App f1 a1) (App f2 a2)+          = f1 `go_s` f2 && a1 `go_s` a2++        go (Cast e1 t1) (Cast e2 t2)+          = e1 `go_s` e2 && t1 `eqCoercion` t2++        go (Tick t1 e1) (Tick t2 e2)+          = t1 == t2 && e1 `go_s` e2++        go _ _ = False+        {-# INLINE go #-}+{-# INLINE cheapEqExpr' #-}++exprIsBig :: Expr b -> Bool+-- ^ Returns @True@ of expressions that are too big to be compared by 'cheapEqExpr'+exprIsBig (Lit _)      = False+exprIsBig (Var _)      = False+exprIsBig (Type _)     = False+exprIsBig (Coercion _) = False+exprIsBig (Lam _ e)    = exprIsBig e+exprIsBig (App f a)    = exprIsBig f || exprIsBig a+exprIsBig (Cast e _)   = exprIsBig e    -- Hopefully coercions are not too big!+exprIsBig (Tick _ e)   = exprIsBig e+exprIsBig _            = True++eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool+-- Compares for equality, modulo alpha+eqExpr in_scope e1 e2+  = go (mkRnEnv2 in_scope) e1 e2+  where+    go env (Var v1) (Var v2)+      | rnOccL env v1 == rnOccR env v2+      = True++    go _   (Lit lit1)    (Lit lit2)      = lit1 == lit2+    go env (Type t1)    (Type t2)        = eqTypeX env t1 t2+    go env (Coercion co1) (Coercion co2) = eqCoercionX env co1 co2+    go env (Cast e1 co1) (Cast e2 co2) = eqCoercionX env co1 co2 && go env e1 e2+    go env (App f1 a1)   (App f2 a2)   = go env f1 f2 && go env a1 a2+    go env (Tick n1 e1)  (Tick n2 e2)  = eqTickish env n1 n2 && go env e1 e2++    go env (Lam b1 e1)  (Lam b2 e2)+      =  eqTypeX env (varType b1) (varType b2)   -- False for Id/TyVar combination+      && go (rnBndr2 env b1 b2) e1 e2++    go env (Let (NonRec v1 r1) e1) (Let (NonRec v2 r2) e2)+      =  go env r1 r2  -- No need to check binder types, since RHSs match+      && go (rnBndr2 env v1 v2) e1 e2++    go env (Let (Rec ps1) e1) (Let (Rec ps2) e2)+      = equalLength ps1 ps2+      && all2 (go env') rs1 rs2 && go env' e1 e2+      where+        (bs1,rs1) = unzip ps1+        (bs2,rs2) = unzip ps2+        env' = rnBndrs2 env bs1 bs2++    go env (Case e1 b1 t1 a1) (Case e2 b2 t2 a2)+      | null a1   -- See Note [Empty case alternatives] in TrieMap+      = null a2 && go env e1 e2 && eqTypeX env t1 t2+      | otherwise+      =  go env e1 e2 && all2 (go_alt (rnBndr2 env b1 b2)) a1 a2++    go _ _ _ = False++    -----------+    go_alt env (c1, bs1, e1) (c2, bs2, e2)+      = c1 == c2 && go (rnBndrs2 env bs1 bs2) e1 e2++eqTickish :: RnEnv2 -> Tickish Id -> Tickish Id -> Bool+eqTickish env (Breakpoint lid lids) (Breakpoint rid rids)+      = lid == rid  &&  map (rnOccL env) lids == map (rnOccR env) rids+eqTickish _ l r = l == r++-- | Finds differences between core expressions, modulo alpha and+-- renaming. Setting @top@ means that the @IdInfo@ of bindings will be+-- checked for differences as well.+diffExpr :: Bool -> RnEnv2 -> CoreExpr -> CoreExpr -> [SDoc]+diffExpr _   env (Var v1)   (Var v2)   | rnOccL env v1 == rnOccR env v2 = []+diffExpr _   _   (Lit lit1) (Lit lit2) | lit1 == lit2                   = []+diffExpr _   env (Type t1)  (Type t2)  | eqTypeX env t1 t2              = []+diffExpr _   env (Coercion co1) (Coercion co2)+                                       | eqCoercionX env co1 co2        = []+diffExpr top env (Cast e1 co1)  (Cast e2 co2)+  | eqCoercionX env co1 co2                = diffExpr top env e1 e2+diffExpr top env (Tick n1 e1)   e2+  | not (tickishIsCode n1)                 = diffExpr top env e1 e2+diffExpr top env e1             (Tick n2 e2)+  | not (tickishIsCode n2)                 = diffExpr top env e1 e2+diffExpr top env (Tick n1 e1)   (Tick n2 e2)+  | eqTickish env n1 n2                    = diffExpr top env e1 e2+ -- The error message of failed pattern matches will contain+ -- generated names, which are allowed to differ.+diffExpr _   _   (App (App (Var absent) _) _)+                 (App (App (Var absent2) _) _)+  | isBottomingId absent && isBottomingId absent2 = []+diffExpr top env (App f1 a1)    (App f2 a2)+  = diffExpr top env f1 f2 ++ diffExpr top env a1 a2+diffExpr top env (Lam b1 e1)  (Lam b2 e2)+  | eqTypeX env (varType b1) (varType b2)   -- False for Id/TyVar combination+  = diffExpr top (rnBndr2 env b1 b2) e1 e2+diffExpr top env (Let bs1 e1) (Let bs2 e2)+  = 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)+  | 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+        diffAlt (c1, bs1, e1) (c2, bs2, e2)+          | c1 /= c2  = [text "alt-cons " <> ppr c1 <> text " /= " <> ppr c2]+          | otherwise = diffExpr top (rnBndrs2 env' bs1 bs2) e1 e2+diffExpr _  _ e1 e2+  = [fsep [ppr e1, text "/=", ppr e2]]++-- | Finds differences between core bindings, see @diffExpr@.+--+-- The main problem here is that while we expect the binds to have the+-- same order in both lists, this is not guaranteed. To do this+-- properly we'd either have to do some sort of unification or check+-- all possible mappings, which would be seriously expensive. So+-- instead we simply match single bindings as far as we can. This+-- leaves us just with mutually recursive and/or mismatching bindings,+-- which we then speculatively match by ordering them. It's by no means+-- perfect, but gets the job done well enough.+diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)]+          -> ([SDoc], RnEnv2)+diffBinds top env binds1 = go (length binds1) env binds1+ where go _    env []     []+          = ([], env)+       go fuel env binds1 binds2+          -- No binds left to compare? Bail out early.+          | null binds1 || null binds2+          = (warn env binds1 binds2, env)+          -- Iterated over all binds without finding a match? Then+          -- try speculatively matching binders by order.+          | fuel == 0+          = if not $ env `inRnEnvL` fst (head binds1)+            then let env' = uncurry (rnBndrs2 env) $ unzip $+                            zip (sort $ map fst binds1) (sort $ map fst binds2)+                 in go (length binds1) env' binds1 binds2+            -- If we have already tried that, give up+            else (warn env binds1 binds2, env)+       go fuel env ((bndr1,expr1):binds1) binds2+          | let matchExpr (bndr,expr) =+                  (not top || null (diffIdInfo env bndr bndr1)) &&+                  null (diffExpr top (rnBndr2 env bndr1 bndr) expr1 expr)+          , (binds2l, (bndr2,_):binds2r) <- break matchExpr binds2+          = go (length binds1) (rnBndr2 env bndr1 bndr2)+                binds1 (binds2l ++ binds2r)+          | otherwise -- No match, so push back (FIXME O(n^2))+          = go (fuel-1) env (binds1++[(bndr1,expr1)]) binds2+       go _ _ _ _ = panic "diffBinds: impossible" -- GHC isn't smart enough++       -- We have tried everything, but couldn't find a good match. So+       -- now we just return the comparison results when we pair up+       -- the binds in a pseudo-random order.+       warn env binds1 binds2 =+         concatMap (uncurry (diffBind env)) (zip binds1' binds2') +++         unmatched "unmatched left-hand:" (drop l binds1') +++         unmatched "unmatched right-hand:" (drop l binds2')+        where binds1' = sortBy (comparing fst) binds1+              binds2' = sortBy (comparing fst) binds2+              l = min (length binds1') (length binds2')+       unmatched _   [] = []+       unmatched txt bs = [text txt $$ ppr (Rec bs)]+       diffBind env (bndr1,expr1) (bndr2,expr2)+         | ds@(_:_) <- diffExpr top env expr1 expr2+         = locBind "in binding" bndr1 bndr2 ds+         | otherwise+         = diffIdInfo env bndr1 bndr2++-- | Find differences in @IdInfo@. We will especially check whether+-- the unfoldings match, if present (see @diffUnfold@).+diffIdInfo :: RnEnv2 -> Var -> Var -> [SDoc]+diffIdInfo env bndr1 bndr2+  | arityInfo info1 == arityInfo info2+    && cafInfo info1 == cafInfo info2+    && oneShotInfo info1 == oneShotInfo info2+    && inlinePragInfo info1 == inlinePragInfo info2+    && occInfo info1 == occInfo info2+    && demandInfo info1 == demandInfo info2+    && callArityInfo info1 == callArityInfo info2+    && levityInfo info1 == levityInfo info2+  = locBind "in unfolding of" bndr1 bndr2 $+    diffUnfold env (unfoldingInfo info1) (unfoldingInfo info2)+  | otherwise+  = locBind "in Id info of" bndr1 bndr2+    [fsep [pprBndr LetBind bndr1, text "/=", pprBndr LetBind bndr2]]+  where info1 = idInfo bndr1; info2 = idInfo bndr2++-- | Find differences in unfoldings. Note that we will not check for+-- differences of @IdInfo@ in unfoldings, as this is generally+-- redundant, and can lead to an exponential blow-up in complexity.+diffUnfold :: RnEnv2 -> Unfolding -> Unfolding -> [SDoc]+diffUnfold _   NoUnfolding    NoUnfolding                 = []+diffUnfold _   BootUnfolding  BootUnfolding               = []+diffUnfold _   (OtherCon cs1) (OtherCon cs2) | cs1 == cs2 = []+diffUnfold env (DFunUnfolding bs1 c1 a1)+               (DFunUnfolding bs2 c2 a2)+  | 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)+               (CoreUnfolding t2 _ _ v2 cl2 wf2 x2 g2)+  | v1 == v2 && cl1 == cl2+    && wf1 == wf2 && x1 == x2 && g1 == g2+  = diffExpr False env t1 t2+diffUnfold _   uf1 uf2+  = [fsep [ppr uf1, text "/=", ppr uf2]]++-- | Add location information to diff messages+locBind :: String -> Var -> Var -> [SDoc] -> [SDoc]+locBind loc b1 b2 diffs = map addLoc diffs+  where addLoc d            = d $$ nest 2 (parens (text loc <+> bindLoc))+        bindLoc | b1 == b2  = ppr b1+                | otherwise = ppr b1 <> char '/' <> ppr b2++{-+************************************************************************+*                                                                      *+                Eta reduction+*                                                                      *+************************************************************************++Note [Eta reduction conditions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We try for eta reduction here, but *only* if we get all the way to an+trivial expression.  We don't want to remove extra lambdas unless we+are going to avoid allocating this thing altogether.++There are some particularly delicate points here:++* We want to eta-reduce if doing so leaves a trivial expression,+  *including* a cast.  For example+       \x. f |> co  -->  f |> co+  (provided co doesn't mention x)++* Eta reduction is not valid in general:+        \x. bot  /=  bot+  This matters, partly for old-fashioned correctness reasons but,+  worse, getting it wrong can yield a seg fault. Consider+        f = \x.f x+        h y = case (case y of { True -> f `seq` True; False -> False }) of+                True -> ...; False -> ...++  If we (unsoundly) eta-reduce f to get f=f, the strictness analyser+  says f=bottom, and replaces the (f `seq` True) with just+  (f `cast` unsafe-co).  BUT, as thing stand, 'f' got arity 1, and it+  *keeps* arity 1 (perhaps also wrongly).  So CorePrep eta-expands+  the definition again, so that it does not termninate after all.+  Result: seg-fault because the boolean case actually gets a function value.+  See #1947.++  So it's important to do the right thing.++* Note [Arity care]: we need to be careful if we just look at f's+  arity. Currently (Dec07), f's arity is visible in its own RHS (see+  Note [Arity robustness] in SimplEnv) so we must *not* trust the+  arity when checking that 'f' is a value.  Otherwise we will+  eta-reduce+      f = \x. f x+  to+      f = f+  Which might change a terminating program (think (f `seq` e)) to a+  non-terminating one.  So we check for being a loop breaker first.++  However for GlobalIds we can look at the arity; and for primops we+  must, since they have no unfolding.++* Regardless of whether 'f' is a value, we always want to+  reduce (/\a -> f a) to f+  This came up in a RULE: foldr (build (/\a -> g a))+  did not match           foldr (build (/\b -> ...something complex...))+  The type checker can insert these eta-expanded versions,+  with both type and dictionary lambdas; hence the slightly+  ad-hoc isDictId++* Never *reduce* arity. For example+      f = \xy. g x y+  Then if h has arity 1 we don't want to eta-reduce because then+  f's arity would decrease, and that is bad++These delicacies are why we don't use exprIsTrivial and exprIsHNF here.+Alas.++Note [Eta reduction with casted arguments]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+    (\(x:t3). f (x |> g)) :: t3 -> t2+  where+    f :: t1 -> t2+    g :: t3 ~ t1+This should be eta-reduced to++    f |> (sym g -> t2)++So we need to accumulate a coercion, pushing it inward (past+variable arguments only) thus:+   f (x |> co_arg) |> co  -->  (f |> (sym co_arg -> co)) x+   f (x:t)         |> co  -->  (f |> (t -> co)) x+   f @ a           |> co  -->  (f |> (forall a.co)) @ a+   f @ (g:t1~t2)   |> co  -->  (f |> (t1~t2 => co)) @ (g:t1~t2)+These are the equations for ok_arg.++It's true that we could also hope to eta reduce these:+    (\xy. (f x |> g) y)+    (\xy. (f x y) |> g)+But the simplifier pushes those casts outwards, so we don't+need to address that here.+-}++-- When updating this function, make sure to update+-- CorePrep.tryEtaReducePrep as well!+tryEtaReduce :: [Var] -> CoreExpr -> Maybe CoreExpr+tryEtaReduce bndrs body+  = go (reverse bndrs) body (mkRepReflCo (exprType body))+  where+    incoming_arity = count isId bndrs++    go :: [Var]            -- Binders, innermost first, types [a3,a2,a1]+       -> CoreExpr         -- Of type tr+       -> Coercion         -- Of type tr ~ ts+       -> Maybe CoreExpr   -- Of type a1 -> a2 -> a3 -> ts+    -- See Note [Eta reduction with casted arguments]+    -- for why we have an accumulating coercion+    go [] fun co+      | ok_fun fun+      , let used_vars = exprFreeVars fun `unionVarSet` tyCoVarsOfCo co+      , not (any (`elemVarSet` used_vars) bndrs)+      = Just (mkCast fun co)   -- Check for any of the binders free in the result+                               -- including the accumulated coercion++    go bs (Tick t e) co+      | tickishFloatable t+      = fmap (Tick t) $ go bs e co+      -- Float app ticks: \x -> Tick t (e x) ==> Tick t e++    go (b : bs) (App fun arg) co+      | Just (co', ticks) <- ok_arg b arg co+      = fmap (flip (foldr mkTick) ticks) $ go bs fun co'+            -- Float arg ticks: \x -> e (Tick t x) ==> Tick t e++    go _ _ _  = Nothing         -- Failure!++    ---------------+    -- Note [Eta reduction conditions]+    ok_fun (App fun (Type {})) = ok_fun fun+    ok_fun (Cast fun _)        = ok_fun fun+    ok_fun (Tick _ expr)       = ok_fun expr+    ok_fun (Var fun_id)        = ok_fun_id fun_id || all ok_lam bndrs+    ok_fun _fun                = False++    ---------------+    ok_fun_id fun = fun_arity fun >= incoming_arity++    ---------------+    fun_arity fun             -- See Note [Arity care]+       | isLocalId fun+       , isStrongLoopBreaker (idOccInfo fun) = 0+       | arity > 0                           = arity+       | isEvaldUnfolding (idUnfolding fun)  = 1+            -- See Note [Eta reduction of an eval'd function]+       | otherwise                           = 0+       where+         arity = idArity fun++    ---------------+    ok_lam v = isTyVar v || isEvVar v++    ---------------+    ok_arg :: Var              -- Of type bndr_t+           -> CoreExpr         -- Of type arg_t+           -> Coercion         -- Of kind (t1~t2)+           -> Maybe (Coercion  -- Of type (arg_t -> t1 ~  bndr_t -> t2)+                               --   (and similarly for tyvars, coercion args)+                    , [Tickish Var])+    -- See Note [Eta reduction with casted arguments]+    ok_arg bndr (Type ty) co+       | Just tv <- getTyVar_maybe ty+       , bndr == tv  = Just (mkHomoForAllCos [tv] co, [])+    ok_arg bndr (Var v) co+       | bndr == v   = let reflCo = mkRepReflCo (idType bndr)+                       in Just (mkFunCo Representational reflCo co, [])+    ok_arg bndr (Cast e co_arg) co+       | (ticks, Var v) <- stripTicksTop tickishFloatable e+       , bndr == v+       = Just (mkFunCo Representational (mkSymCo co_arg) co, ticks)+       -- The simplifier combines multiple casts into one,+       -- so we can have a simple-minded pattern match here+    ok_arg bndr (Tick t arg) co+       | tickishFloatable t, Just (co', ticks) <- ok_arg bndr arg co+       = Just (co', t:ticks)++    ok_arg _ _ _ = Nothing++{-+Note [Eta reduction of an eval'd function]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In Haskell it is not true that    f = \x. f x+because f might be bottom, and 'seq' can distinguish them.++But it *is* true that   f = f `seq` \x. f x+and we'd like to simplify the latter to the former.  This amounts+to the rule that+  * when there is just *one* value argument,+  * f is not bottom+we can eta-reduce    \x. f x  ===>  f++This turned up in #7542.+++************************************************************************+*                                                                      *+\subsection{Determining non-updatable right-hand-sides}+*                                                                      *+************************************************************************++Top-level constructor applications can usually be allocated+statically, but they can't if the constructor, or any of the+arguments, come from another DLL (because we can't refer to static+labels in other DLLs).++If this happens we simply make the RHS into an updatable thunk,+and 'execute' it rather than allocating it statically.+-}++{-+************************************************************************+*                                                                      *+\subsection{Type utilities}+*                                                                      *+************************************************************************+-}++-- | True if the type has no non-bottom elements, e.g. when it is an empty+-- datatype, or a GADT with non-satisfiable type parameters, e.g. Int :~: Bool.+-- See Note [Bottoming expressions]+--+-- See Note [No alternatives lint check] for another use of this function.+isEmptyTy :: Type -> Bool+isEmptyTy ty+    -- Data types where, given the particular type parameters, no data+    -- constructor matches, are empty.+    -- This includes data types with no constructors, e.g. Data.Void.Void.+    | Just (tc, inst_tys) <- splitTyConApp_maybe ty+    , Just dcs <- tyConDataCons_maybe tc+    , all (dataConCannotMatch inst_tys) dcs+    = True+    | otherwise+    = False++{-+*****************************************************+*+* StaticPtr+*+*****************************************************+-}++-- | @collectMakeStaticArgs (makeStatic t srcLoc e)@ yields+-- @Just (makeStatic, t, srcLoc, e)@.+--+-- Returns @Nothing@ for every other expression.+collectMakeStaticArgs+  :: CoreExpr -> Maybe (CoreExpr, Type, CoreExpr, CoreExpr)+collectMakeStaticArgs e+    | (fun@(Var b), [Type t, loc, arg], _) <- collectArgsTicks (const True) e+    , idName b == makeStaticName = Just (fun, t, loc, arg)+collectMakeStaticArgs _          = Nothing++{-+************************************************************************+*                                                                      *+\subsection{Join points}+*                                                                      *+************************************************************************+-}++-- | Does this binding bind a join point (or a recursive group of join points)?+isJoinBind :: CoreBind -> Bool+isJoinBind (NonRec b _)       = isJoinId b+isJoinBind (Rec ((b, _) : _)) = isJoinId b+isJoinBind _                  = False++dumpIdInfoOfProgram :: (IdInfo -> SDoc) -> CoreProgram -> SDoc+dumpIdInfoOfProgram ppr_id_info binds = vcat (map printId ids)+  where+  ids = sortBy (stableNameCmp `on` getName) (concatMap getIds binds)+  getIds (NonRec i _) = [ i ]+  getIds (Rec bs)     = map fst bs+  printId id | isExportedId id = ppr id <> colon <+> (ppr_id_info (idInfo id))+             | otherwise       = empty

compiler/GHC/CoreToIface.hs view

@@ -51,7 +51,7 @@ import DataCon import Id import IdInfo-import CoreSyn+import GHC.Core import TyCon hiding ( pprPromotionQuote ) import CoAxiom import TysPrim ( eqPrimTyCon, eqReprPrimTyCon )@@ -71,6 +71,7 @@ import TyCoRep import TyCoTidy ( tidyCo ) import Demand ( isTopSig )+import Cpr ( topCprSig )  import Data.Maybe ( catMaybes ) @@ -300,7 +301,6 @@                             fr' = fr `delVarSet` tv      go_prov :: UnivCoProvenance -> IfaceUnivCoProv-    go_prov UnsafeCoerceProv    = IfaceUnsafeCoerceProv     go_prov (PhantomProv co)    = IfacePhantomProv (go co)     go_prov (ProofIrrelProv co) = IfaceProofIrrelProv (go co)     go_prov (PluginProv str)    = IfacePluginProv str@@ -422,7 +422,7 @@                                (toIfaceType (idType id))                                (toIfaceIdInfo (idInfo id))                                (toIfaceJoinInfo (isJoinId_maybe id))-  -- Put into the interface file any IdInfo that CoreTidy.tidyLetBndr+  -- Put into the interface file any IdInfo that GHC.Core.Op.Tidy.tidyLetBndr   -- has left on the Id.  See Note [IdInfo on nested let-bindings] in GHC.Iface.Syntax  toIfaceIdDetails :: IdDetails -> IfaceIdDetails@@ -442,10 +442,8 @@  toIfaceIdInfo :: IdInfo -> IfaceIdInfo toIfaceIdInfo id_info-  = case catMaybes [arity_hsinfo, caf_hsinfo, strict_hsinfo,-                    inline_hsinfo,  unfold_hsinfo, levity_hsinfo] of-       []    -> NoInfo-       infos -> HasInfo infos+  = catMaybes [arity_hsinfo, caf_hsinfo, strict_hsinfo, cpr_hsinfo,+               inline_hsinfo,  unfold_hsinfo, levity_hsinfo]                -- NB: strictness and arity must appear in the list before unfolding                -- See GHC.IfaceToCore.tcUnfolding   where@@ -466,6 +464,10 @@     strict_hsinfo | not (isTopSig sig_info) = Just (HsStrictness sig_info)                   | otherwise               = Nothing +    ------------  CPR --------------+    cpr_info = cprInfo id_info+    cpr_hsinfo | cpr_info /= topCprSig = Just (HsCpr cpr_info)+               | otherwise             = Nothing     ------------  Unfolding  --------------     unfold_hsinfo = toIfUnfolding loop_breaker (unfoldingInfo id_info)     loop_breaker  = isStrongLoopBreaker (occInfo id_info)

+ compiler/GHC/Driver/Backpack/Syntax.hs view

@@ -0,0 +1,83 @@+-- | This is the syntax for bkp files which are parsed in 'ghc --backpack'+-- mode.  This syntax is used purely for testing purposes.++module GHC.Driver.Backpack.Syntax (+    -- * Backpack abstract syntax+    HsUnitId(..),+    LHsUnitId,+    HsModuleSubst,+    LHsModuleSubst,+    HsModuleId(..),+    LHsModuleId,+    HsComponentId(..),+    LHsUnit, HsUnit(..),+    LHsUnitDecl, HsUnitDecl(..),+    IncludeDecl(..),+    LRenaming, Renaming(..),+    ) where++import GhcPrelude++import GHC.Driver.Phases+import GHC.Hs+import SrcLoc+import Outputable+import Module+import UnitInfo++{-+************************************************************************+*                                                                      *+                        User syntax+*                                                                      *+************************************************************************+-}++data HsComponentId = HsComponentId {+    hsPackageName :: PackageName,+    hsComponentId :: ComponentId+    }++instance Outputable HsComponentId where+    ppr (HsComponentId _pn cid) = ppr cid -- todo debug with pn++data HsUnitId n = HsUnitId (Located n) [LHsModuleSubst n]+type LHsUnitId n = Located (HsUnitId n)++type HsModuleSubst n = (Located ModuleName, LHsModuleId n)+type LHsModuleSubst n = Located (HsModuleSubst n)++data HsModuleId n = HsModuleVar (Located ModuleName)+                  | HsModuleId (LHsUnitId n) (Located ModuleName)+type LHsModuleId n = Located (HsModuleId n)++-- | Top level @unit@ declaration in a Backpack file.+data HsUnit n = HsUnit {+        hsunitName :: Located n,+        hsunitBody :: [LHsUnitDecl n]+    }+type LHsUnit n = Located (HsUnit n)++-- | A declaration in a package, e.g. a module or signature definition,+-- or an include.+data HsUnitDecl n+    = DeclD   HscSource (Located ModuleName) (Maybe (Located HsModule))+    | IncludeD   (IncludeDecl n)+type LHsUnitDecl n = Located (HsUnitDecl n)++-- | An include of another unit+data IncludeDecl n = IncludeDecl {+        idUnitId :: LHsUnitId n,+        idModRenaming :: Maybe [ LRenaming ],+        -- | Is this a @dependency signature@ include?  If so,+        -- we don't compile this include when we instantiate this+        -- unit (as there should not be any modules brought into+        -- scope.)+        idSignatureInclude :: Bool+    }++-- | Rename a module from one name to another.  The identity renaming+-- means that the module should be brought into scope.+data Renaming = Renaming { renameFrom :: Located ModuleName+                         , renameTo :: Maybe (Located ModuleName) }+type LRenaming = Located Renaming

+ compiler/GHC/Driver/CmdLine.hs view

@@ -0,0 +1,339 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveFunctor #-}++-------------------------------------------------------------------------------+--+-- | Command-line parser+--+-- This is an abstract command-line parser used by DynFlags.+--+-- (c) The University of Glasgow 2005+--+-------------------------------------------------------------------------------++module GHC.Driver.CmdLine+    (+      processArgs, OptKind(..), GhcFlagMode(..),+      CmdLineP(..), getCmdLineState, putCmdLineState,+      Flag(..), defFlag, defGhcFlag, defGhciFlag, defHiddenFlag,+      errorsToGhcException,++      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++import Control.Monad (liftM, ap)++--------------------------------------------------------+--         The Flag and OptKind types+--------------------------------------------------------++data Flag m = Flag+    {   flagName    :: String,     -- Flag, without the leading "-"+        flagOptKind :: OptKind m,  -- What to do if we see it+        flagGhcMode :: GhcFlagMode    -- Which modes this flag affects+    }++defFlag :: String -> OptKind m -> Flag m+defFlag name optKind = Flag name optKind AllModes++defGhcFlag :: String -> OptKind m -> Flag m+defGhcFlag name optKind = Flag name optKind OnlyGhc++defGhciFlag :: String -> OptKind m -> Flag m+defGhciFlag name optKind = Flag name optKind OnlyGhci++defHiddenFlag :: String -> OptKind m -> Flag m+defHiddenFlag name optKind = Flag name optKind HiddenFlag++-- | GHC flag modes describing when a flag has an effect.+data GhcFlagMode+    = OnlyGhc  -- ^ The flag only affects the non-interactive GHC+    | OnlyGhci -- ^ The flag only affects the interactive GHC+    | AllModes -- ^ The flag affects multiple ghc modes+    | HiddenFlag -- ^ This flag should not be seen in cli completion++data OptKind m                             -- Suppose the flag is -f+    = NoArg     (EwM m ())                 -- -f all by itself+    | HasArg    (String -> EwM m ())       -- -farg or -f arg+    | SepArg    (String -> EwM m ())       -- -f arg+    | Prefix    (String -> EwM m ())       -- -farg+    | OptPrefix (String -> EwM m ())       -- -f or -farg (i.e. the arg is optional)+    | OptIntSuffix (Maybe Int -> EwM m ()) -- -f or -f=n; pass n to fn+    | IntSuffix (Int -> EwM m ())          -- -f or -f=n; pass n to fn+    | FloatSuffix (Float -> EwM m ())      -- -f or -f=n; pass n to fn+    | PassFlag  (String -> EwM m ())       -- -f; pass "-f" fn+    | AnySuffix (String -> EwM m ())       -- -f or -farg; pass entire "-farg" to fn+++--------------------------------------------------------+--         The EwM monad+--------------------------------------------------------++-- | 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++-- EwM ("errors and warnings monad") is a monad+-- transformer for m that adds an (err, warn) state+newtype EwM m a = EwM { unEwM :: Located String -- Current parse arg+                              -> Errs -> Warns+                              -> m (Errs, Warns, a) }++instance Monad m => Functor (EwM m) where+    fmap = liftM++instance Monad m => Applicative (EwM m) where+    pure v = EwM (\_ e w -> return (e, w, v))+    (<*>) = ap++instance Monad m => Monad (EwM m) where+    (EwM f) >>= k = EwM (\l e w -> do (e', w', r) <- f l e w+                                      unEwM (k r) l e' w')++runEwM :: EwM m a -> m (Errs, Warns, a)+runEwM action = unEwM action (panic "processArgs: no arg yet") emptyBag emptyBag++setArg :: Located String -> EwM m () -> EwM m ()+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` Err (L loc e), ws, ()))++addWarn :: Monad m => String -> EwM m ()+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+    addFlagWarn ReasonDeprecatedFlag (arg ++ " is deprecated: " ++ s)++getArg :: Monad m => EwM m String+getArg = EwM (\(L _ arg) es ws -> return (es, ws, arg))++getCurLoc :: Monad m => EwM m SrcSpan+getCurLoc = EwM (\(L loc _) es ws -> return (es, ws, loc))++liftEwM :: Monad m => m a -> EwM m a+liftEwM action = EwM (\_ es ws -> do { r <- action; return (es, ws, r) })+++--------------------------------------------------------+-- A state monad for use in the command-line parser+--------------------------------------------------------++-- (CmdLineP s) typically instantiates the 'm' in (EwM m) and (OptKind m)+newtype CmdLineP s a = CmdLineP { runCmdLine :: s -> (a, s) }+    deriving (Functor)++instance Applicative (CmdLineP s) where+    pure a = CmdLineP $ \s -> (a, s)+    (<*>) = ap++instance Monad (CmdLineP s) where+    m >>= k = CmdLineP $ \s ->+                  let (a, s') = runCmdLine m s+                  in runCmdLine (k a) s'+++getCmdLineState :: CmdLineP s s+getCmdLineState   = CmdLineP $ \s -> (s,s)+putCmdLineState :: s -> CmdLineP s ()+putCmdLineState s = CmdLineP $ \_ -> ((),s)+++--------------------------------------------------------+--         Processing arguments+--------------------------------------------------------++processArgs :: Monad m+            => [Flag m]               -- cmdline parser spec+            -> [Located String]       -- args+            -> m ( [Located String],  -- spare args+                   [Err],  -- errors+                   [Warn] ) -- warnings+processArgs spec args = do+    (errs, warns, spare) <- runEwM action+    return (spare, bagToList errs, bagToList warns)+  where+    action = process args []++    -- process :: [Located String] -> [Located String] -> EwM m [Located String]+    process [] spare = return (reverse spare)++    process (locArg@(L _ ('-' : arg)) : args) spare =+        case findArg spec arg of+            Just (rest, opt_kind) ->+                case processOneArg opt_kind rest arg args of+                    Left err ->+                        let b = process args spare+                        in (setArg locArg $ addErr err) >> b++                    Right (action,rest) ->+                        let b = process rest spare+                        in (setArg locArg $ action) >> b++            Nothing -> process args (locArg : spare)++    process (arg : args) spare = process args (arg : spare)+++processOneArg :: OptKind m -> String -> String -> [Located String]+              -> Either String (EwM m (), [Located String])+processOneArg opt_kind rest arg args+  = let dash_arg = '-' : arg+        rest_no_eq = dropEq rest+    in case opt_kind of+        NoArg  a -> ASSERT(null rest) Right (a, args)++        HasArg f | notNull rest_no_eq -> Right (f rest_no_eq, args)+                 | otherwise -> case args of+                                    []               -> missingArgErr dash_arg+                                    (L _ arg1:args1) -> Right (f arg1, args1)++        -- See #9776+        SepArg f -> case args of+                        []               -> missingArgErr dash_arg+                        (L _ arg1:args1) -> Right (f arg1, args1)++        -- See #12625+        Prefix f | notNull rest_no_eq -> Right (f rest_no_eq, args)+                 | otherwise          -> missingArgErr  dash_arg++        PassFlag f  | notNull rest -> unknownFlagErr dash_arg+                    | otherwise    -> Right (f dash_arg, args)++        OptIntSuffix f | null rest                     -> Right (f Nothing,  args)+                       | Just n <- parseInt rest_no_eq -> Right (f (Just n), args)+                       | otherwise -> Left ("malformed integer argument in " ++ dash_arg)++        IntSuffix f | Just n <- parseInt rest_no_eq -> Right (f n, args)+                    | otherwise -> Left ("malformed integer argument in " ++ dash_arg)++        FloatSuffix f | Just n <- parseFloat rest_no_eq -> Right (f n, args)+                      | otherwise -> Left ("malformed float argument in " ++ dash_arg)++        OptPrefix f       -> Right (f rest_no_eq, args)+        AnySuffix f       -> Right (f dash_arg, args)++findArg :: [Flag m] -> String -> Maybe (String, OptKind m)+findArg spec arg =+    case sortBy (compare `on` (length . fst)) -- prefer longest matching flag+           [ (removeSpaces rest, optKind)+           | flag <- spec,+             let optKind  = flagOptKind flag,+             Just rest <- [stripPrefix (flagName flag) arg],+             arg_ok optKind rest arg ]+    of+        []      -> Nothing+        (one:_) -> Just one++arg_ok :: OptKind t -> [Char] -> String -> Bool+arg_ok (NoArg           _)  rest _   = null rest+arg_ok (HasArg          _)  _    _   = True+arg_ok (SepArg          _)  rest _   = null rest+arg_ok (Prefix          _)  _    _   = True -- Missing argument checked for in processOneArg t+                                            -- to improve error message (#12625)+arg_ok (OptIntSuffix    _)  _    _   = True+arg_ok (IntSuffix       _)  _    _   = True+arg_ok (FloatSuffix     _)  _    _   = True+arg_ok (OptPrefix       _)  _    _   = True+arg_ok (PassFlag        _)  rest _   = null rest+arg_ok (AnySuffix       _)  _    _   = True++-- | Parse an Int+--+-- Looks for "433" or "=342", with no trailing gubbins+--   * n or =n      => Just n+--   * gibberish    => Nothing+parseInt :: String -> Maybe Int+parseInt s = case reads s of+                 ((n,""):_) -> Just n+                 _          -> Nothing++parseFloat :: String -> Maybe Float+parseFloat s = case reads s of+                   ((n,""):_) -> Just n+                   _          -> Nothing++-- | Discards a leading equals sign+dropEq :: String -> String+dropEq ('=' : s) = s+dropEq s         = s++unknownFlagErr :: String -> Either String a+unknownFlagErr f = Left ("unrecognised flag: " ++ f)++missingArgErr :: String -> Either String a+missingArgErr f = Left ("missing argument for flag: " ++ f)++--------------------------------------------------------+-- Utils+--------------------------------------------------------+++-- See Note [Handling errors when parsing flags]+errorsToGhcException :: [(String,    -- Location+                          String)]   -- Error+                     -> GhcException+errorsToGhcException errs =+    UsageError $ intercalate "\n" $ [ l ++ ": " ++ e | (l, e) <- errs ]++{- Note [Handling errors when parsing commandline flags]++Parsing of static and mode flags happens before any session is started, i.e.,+before the first call to 'GHC.withGhc'. Therefore, to report errors for+invalid usage of these two types of flags, we can not call any function that+needs DynFlags, as there are no DynFlags available yet (unsafeGlobalDynFlags+is not set either). So we always print "on the commandline" as the location,+which is true except for Api users, which is probably ok.++When reporting errors for invalid usage of dynamic flags we /can/ make use of+DynFlags, and we do so explicitly in DynFlags.parseDynamicFlagsFull.++Before, we called unsafeGlobalDynFlags when an invalid (combination of)+flag(s) was given on the commandline, resulting in panics (#9963).+-}

+ compiler/GHC/Driver/Hooks.hs view

@@ -0,0 +1,121 @@+-- \section[Hooks]{Low level API hooks}++-- NB: this module is SOURCE-imported by DynFlags, and should primarily+--     refer to *types*, rather than *code*++{-# LANGUAGE CPP, RankNTypes #-}++module GHC.Driver.Hooks+   ( Hooks+   , emptyHooks+   , lookupHook+   , getHooked+     -- the hooks:+   , dsForeignsHook+   , tcForeignImportsHook+   , tcForeignExportsHook+   , hscFrontendHook+   , hscCompileCoreExprHook+   , ghcPrimIfaceHook+   , runPhaseHook+   , runMetaHook+   , linkHook+   , runRnSpliceHook+   , getValueSafelyHook+   , createIservProcessHook+   , stgToCmmHook+   , cmmToRawCmmHook+   )+where++import GhcPrelude++import GHC.Driver.Session+import GHC.Driver.Pipeline.Monad+import GHC.Driver.Types+import GHC.Hs.Decls+import GHC.Hs.Binds+import GHC.Hs.Expr+import OrdList+import TcRnTypes+import Bag+import RdrName+import Name+import Id+import GHC.Core+import GHCi.RemoteTypes+import SrcLoc+import Type+import System.Process+import BasicTypes+import Module+import TyCon+import CostCentre+import GHC.Stg.Syntax+import Stream+import GHC.Cmm+import GHC.Hs.Extension++import Data.Maybe++{-+************************************************************************+*                                                                      *+\subsection{Hooks}+*                                                                      *+************************************************************************+-}++-- | Hooks can be used by GHC API clients to replace parts of+--   the compiler pipeline. If a hook is not installed, GHC+--   uses the default built-in behaviour++emptyHooks :: Hooks+emptyHooks = Hooks+  { dsForeignsHook         = Nothing+  , tcForeignImportsHook   = Nothing+  , tcForeignExportsHook   = Nothing+  , hscFrontendHook        = Nothing+  , hscCompileCoreExprHook = Nothing+  , ghcPrimIfaceHook       = Nothing+  , runPhaseHook           = Nothing+  , runMetaHook            = Nothing+  , linkHook               = Nothing+  , runRnSpliceHook        = Nothing+  , getValueSafelyHook     = Nothing+  , createIservProcessHook = Nothing+  , stgToCmmHook           = Nothing+  , cmmToRawCmmHook        = Nothing+  }++data Hooks = Hooks+  { 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)+  , ghcPrimIfaceHook       :: Maybe ModIface+  , runPhaseHook           :: Maybe (PhasePlus -> FilePath -> DynFlags+                                         -> CompPipeline (PhasePlus, FilePath))+  , runMetaHook            :: Maybe (MetaHook TcM)+  , 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)+  , stgToCmmHook           :: Maybe (DynFlags -> Module -> [TyCon] -> CollectedCCs+                                 -> [CgStgTopBinding] -> HpcInfo -> Stream IO CmmGroup ())+  , cmmToRawCmmHook        :: forall a . Maybe (DynFlags -> Maybe Module -> Stream IO CmmGroupSRTs a+                                 -> IO (Stream IO RawCmmGroup a))+  }++getHooked :: (Functor f, HasDynFlags f) => (Hooks -> Maybe a) -> a -> f a+getHooked hook def = fmap (lookupHook hook def) getDynFlags++lookupHook :: (Hooks -> Maybe a) -> a -> DynFlags -> a+lookupHook hook def = fromMaybe def . hook . hooks

+ compiler/GHC/Driver/Hooks.hs-boot view

@@ -0,0 +1,7 @@+module GHC.Driver.Hooks where++import GhcPrelude ()++data Hooks++emptyHooks :: Hooks

+ compiler/GHC/Driver/Monad.hs view

@@ -0,0 +1,204 @@+{-# LANGUAGE CPP, DeriveFunctor, RankNTypes #-}+{-# OPTIONS_GHC -funbox-strict-fields #-}+-- -----------------------------------------------------------------------------+--+-- (c) The University of Glasgow, 2010+--+-- The Session type and related functionality+--+-- -----------------------------------------------------------------------------++module GHC.Driver.Monad (+        -- * 'Ghc' monad stuff+        GhcMonad(..),+        Ghc(..),+        GhcT(..), liftGhcT,+        reflectGhc, reifyGhc,+        getSessionDynFlags,+        liftIO,+        Session(..), withSession, modifySession, withTempSession,++        -- ** Warnings+        logWarnings, printException,+        WarnErrLogger, defaultWarnErrLogger+  ) where++import GhcPrelude++import MonadUtils+import GHC.Driver.Types+import GHC.Driver.Session+import Exception+import ErrUtils++import Control.Monad+import Data.IORef++-- -----------------------------------------------------------------------------+-- | A monad that has all the features needed by GHC API calls.+--+-- In short, a GHC monad+--+--   - allows embedding of IO actions,+--+--   - can log warnings,+--+--   - allows handling of (extensible) exceptions, and+--+--   - maintains a current session.+--+-- If you do not use 'Ghc' or 'GhcT', make sure to call 'GHC.initGhcMonad'+-- before any call to the GHC API functions can occur.+--+class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m where+  getSession :: m HscEnv+  setSession :: HscEnv -> m ()++-- | Call the argument with the current session.+withSession :: GhcMonad m => (HscEnv -> m a) -> m a+withSession f = getSession >>= f++-- | Grabs the DynFlags from the Session+getSessionDynFlags :: GhcMonad m => m DynFlags+getSessionDynFlags = withSession (return . hsc_dflags)++-- | Set the current session to the result of applying the current session to+-- the argument.+modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()+modifySession f = do h <- getSession+                     setSession $! f h++withSavedSession :: GhcMonad m => m a -> m a+withSavedSession m = do+  saved_session <- getSession+  m `gfinally` setSession saved_session++-- | Call an action with a temporarily modified Session.+withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a+withTempSession f m =+  withSavedSession $ modifySession f >> m++-- -----------------------------------------------------------------------------+-- | A monad that allows logging of warnings.++logWarnings :: GhcMonad m => WarningMessages -> m ()+logWarnings warns = do+  dflags <- getSessionDynFlags+  liftIO $ printOrThrowWarnings dflags warns++-- -----------------------------------------------------------------------------+-- | A minimal implementation of a 'GhcMonad'.  If you need a custom monad,+-- e.g., to maintain additional state consider wrapping this monad or using+-- 'GhcT'.+newtype Ghc a = Ghc { unGhc :: Session -> IO a } deriving (Functor)++-- | The Session is a handle to the complete state of a compilation+-- session.  A compilation session consists of a set of modules+-- constituting the current program or library, the context for+-- interactive evaluation, and various caches.+data Session = Session !(IORef HscEnv)++instance Applicative Ghc where+  pure a = Ghc $ \_ -> return a+  g <*> m = do f <- g; a <- m; return (f a)++instance Monad Ghc where+  m >>= g  = Ghc $ \s -> do a <- unGhc m s; unGhc (g a) s++instance MonadIO Ghc where+  liftIO ioA = Ghc $ \_ -> ioA++instance MonadFix Ghc where+  mfix f = Ghc $ \s -> mfix (\x -> unGhc (f x) s)++instance ExceptionMonad Ghc where+  gcatch act handle =+      Ghc $ \s -> unGhc act s `gcatch` \e -> unGhc (handle e) s+  gmask f =+      Ghc $ \s -> gmask $ \io_restore ->+                             let+                                g_restore (Ghc m) = Ghc $ \s -> io_restore (m s)+                             in+                                unGhc (f g_restore) s++instance HasDynFlags Ghc where+  getDynFlags = getSessionDynFlags++instance GhcMonad Ghc where+  getSession = Ghc $ \(Session r) -> readIORef r+  setSession s' = Ghc $ \(Session r) -> writeIORef r s'++-- | Reflect a computation in the 'Ghc' monad into the 'IO' monad.+--+-- You can use this to call functions returning an action in the 'Ghc' monad+-- inside an 'IO' action.  This is needed for some (too restrictive) callback+-- arguments of some library functions:+--+-- > libFunc :: String -> (Int -> IO a) -> IO a+-- > ghcFunc :: Int -> Ghc a+-- >+-- > ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a+-- > ghcFuncUsingLibFunc str =+-- >   reifyGhc $ \s ->+-- >     libFunc $ \i -> do+-- >       reflectGhc (ghcFunc i) s+--+reflectGhc :: Ghc a -> Session -> IO a+reflectGhc m = unGhc m++-- > Dual to 'reflectGhc'.  See its documentation.+reifyGhc :: (Session -> IO a) -> Ghc a+reifyGhc act = Ghc $ act++-- -----------------------------------------------------------------------------+-- | A monad transformer to add GHC specific features to another monad.+--+-- Note that the wrapped monad must support IO and handling of exceptions.+newtype GhcT m a = GhcT { unGhcT :: Session -> m a }+    deriving (Functor)++liftGhcT :: m a -> GhcT m a+liftGhcT m = GhcT $ \_ -> m++instance Applicative m => Applicative (GhcT m) where+  pure x  = GhcT $ \_ -> pure x+  g <*> m = GhcT $ \s -> unGhcT g s <*> unGhcT m s++instance Monad m => Monad (GhcT m) where+  m >>= k  = GhcT $ \s -> do a <- unGhcT m s; unGhcT (k a) s++instance MonadIO m => MonadIO (GhcT m) where+  liftIO ioA = GhcT $ \_ -> liftIO ioA++instance ExceptionMonad m => ExceptionMonad (GhcT m) where+  gcatch act handle =+      GhcT $ \s -> unGhcT act s `gcatch` \e -> unGhcT (handle e) s+  gmask f =+      GhcT $ \s -> gmask $ \io_restore ->+                           let+                              g_restore (GhcT m) = GhcT $ \s -> io_restore (m s)+                           in+                              unGhcT (f g_restore) s++instance MonadIO m => HasDynFlags (GhcT m) where+  getDynFlags = GhcT $ \(Session r) -> liftM hsc_dflags (liftIO $ readIORef r)++instance ExceptionMonad m => GhcMonad (GhcT m) where+  getSession = GhcT $ \(Session r) -> liftIO $ readIORef r+  setSession s' = GhcT $ \(Session r) -> liftIO $ writeIORef r s'+++-- | Print the error message and all warnings.  Useful inside exception+--   handlers.  Clears warnings after printing.+printException :: GhcMonad m => SourceError -> m ()+printException err = do+  dflags <- getSessionDynFlags+  liftIO $ printBagOfErrors dflags (srcErrorMessages err)++-- | A function called to log warnings and errors.+type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()++defaultWarnErrLogger :: WarnErrLogger+defaultWarnErrLogger Nothing  = return ()+defaultWarnErrLogger (Just e) = printException e+

+ compiler/GHC/Driver/Packages.hs view

@@ -0,0 +1,2215 @@+-- (c) The University of Glasgow, 2006++{-# LANGUAGE CPP, ScopedTypeVariables, BangPatterns, FlexibleContexts #-}++-- | Package manipulation+module GHC.Driver.Packages (+        module UnitInfo,++        -- * Reading the package config, and processing cmdline args+        PackageState(preloadPackages, explicitPackages, moduleNameProvidersMap, requirementContext),+        PackageDatabase (..),+        UnitInfoMap,+        emptyPackageState,+        initPackages,+        readPackageDatabases,+        readPackageDatabase,+        getPackageConfRefs,+        resolvePackageDatabase,+        listUnitInfoMap,++        -- * Querying the package config+        lookupUnit,+        lookupUnit',+        lookupInstalledPackage,+        lookupPackageName,+        improveUnitId,+        searchPackageId,+        getPackageDetails,+        getInstalledPackageDetails,+        componentIdString,+        displayInstalledUnitId,+        listVisibleModuleNames,+        lookupModuleInAllPackages,+        lookupModuleWithSuggestions,+        lookupPluginModuleWithSuggestions,+        LookupResult(..),+        ModuleSuggestion(..),+        ModuleOrigin(..),+        UnusablePackageReason(..),+        pprReason,++        -- * Inspecting the set of packages in scope+        getPackageIncludePath,+        getPackageLibraryPath,+        getPackageLinkOpts,+        getPackageExtraCcOpts,+        getPackageFrameworkPath,+        getPackageFrameworks,+        getUnitInfoMap,+        getPreloadPackagesAnd,++        collectArchives,+        collectIncludeDirs, collectLibraryPaths, collectLinkOpts,+        packageHsLibs, getLibs,++        -- * Utils+        unwireUnitId,+        pprFlag,+        pprPackages,+        pprPackagesSimple,+        pprModuleMap,+        isIndefinite,+        isDllName+    )+where++#include "HsVersions.h"++import GhcPrelude++import GHC.PackageDb+import UnitInfo+import GHC.Driver.Session+import Name             ( Name, nameModule_maybe )+import UniqFM+import UniqDFM+import UniqSet+import Module+import Util+import Panic+import GHC.Platform+import Outputable+import Maybes++import System.Environment ( getEnv )+import FastString+import ErrUtils         ( debugTraceMsg, MsgDoc, dumpIfSet_dyn,+                          withTiming, DumpFormat (..) )+import Exception++import System.Directory+import System.FilePath as FilePath+import qualified System.FilePath.Posix as FilePath.Posix+import Control.Monad+import Data.Graph (stronglyConnComp, SCC(..))+import Data.Char ( toUpper )+import Data.List as List+import Data.Map (Map)+import Data.Set (Set)+import Data.Monoid (First(..))+import qualified Data.Semigroup as Semigroup+import qualified Data.Map as Map+import qualified Data.Map.Strict as MapStrict+import qualified Data.Set as Set+import Data.Version++-- ---------------------------------------------------------------------------+-- The Package state++-- | Package state is all stored in 'DynFlags', including the details of+-- all packages, which packages are exposed, and which modules they+-- provide.+--+-- The package state is computed by 'initPackages', and kept in DynFlags.+-- It is influenced by various package flags:+--+--   * @-package <pkg>@ and @-package-id <pkg>@ cause @<pkg>@ to become exposed.+--     If @-hide-all-packages@ was not specified, these commands also cause+--      all other packages with the same name to become hidden.+--+--   * @-hide-package <pkg>@ causes @<pkg>@ to become hidden.+--+--   * (there are a few more flags, check below for their semantics)+--+-- The package state has the following properties.+--+--   * Let @exposedPackages@ be the set of packages thus exposed.+--     Let @depExposedPackages@ be the transitive closure from @exposedPackages@ of+--     their dependencies.+--+--   * 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+--     from @depExposedPackages@ are valid.+--+--   * When linking in a compilation manager mode, we link in packages the+--     program depends on (the compiler knows this list by the+--     time it gets to the link step).  Also, we link in all packages+--     which were mentioned with preload @-package@ flags on the command-line,+--     or are a transitive dependency of same, or are \"base\"\/\"rts\".+--     The reason for this is that we might need packages which don't+--     contain any Haskell modules, and therefore won't be discovered+--     by the normal mechanism of dependency tracking.++-- Notes on DLLs+-- ~~~~~~~~~~~~~+-- When compiling module A, which imports module B, we need to+-- know whether B will be in the same DLL as A.+--      If it's in the same DLL, we refer to B_f_closure+--      If it isn't, we refer to _imp__B_f_closure+-- When compiling A, we record in B's Module value whether it's+-- in a different DLL, by setting the DLL flag.++-- | Given a module name, there may be multiple ways it came into scope,+-- possibly simultaneously.  This data type tracks all the possible ways+-- it could have come into scope.  Warning: don't use the record functions,+-- they're partial!+data ModuleOrigin =+    -- | Module is hidden, and thus never will be available for import.+    -- (But maybe the user didn't realize), so we'll still keep track+    -- of these modules.)+    ModHidden+    -- | Module is unavailable because the package is unusable.+  | ModUnusable UnusablePackageReason+    -- | Module is public, and could have come from some places.+  | ModOrigin {+        -- | @Just False@ means that this module is in+        -- someone's @exported-modules@ list, but that package is hidden;+        -- @Just True@ means that it is available; @Nothing@ means neither+        -- applies.+        fromOrigPackage :: Maybe Bool+        -- | Is the module available from a reexport of an exposed package?+        -- There could be multiple.+      , fromExposedReexport :: [UnitInfo]+        -- | Is the module available from a reexport of a hidden package?+      , fromHiddenReexport :: [UnitInfo]+        -- | Did the module export come from a package flag? (ToDo: track+        -- more information.+      , fromPackageFlag :: Bool+      }++instance Outputable ModuleOrigin where+    ppr ModHidden = text "hidden module"+    ppr (ModUnusable _) = text "unusable module"+    ppr (ModOrigin e res rhs f) = sep (punctuate comma (+        (case e of+            Nothing -> []+            Just False -> [text "hidden package"]+            Just True -> [text "exposed package"]) +++        (if null res+            then []+            else [text "reexport by" <+>+                    sep (map (ppr . packageConfigId) res)]) +++        (if null rhs+            then []+            else [text "hidden reexport by" <+>+                    sep (map (ppr . packageConfigId) res)]) +++        (if f then [text "package flag"] else [])+        ))++-- | Smart constructor for a module which is in @exposed-modules@.  Takes+-- as an argument whether or not the defining package is exposed.+fromExposedModules :: Bool -> ModuleOrigin+fromExposedModules e = ModOrigin (Just e) [] [] False++-- | Smart constructor for a module which is in @reexported-modules@.  Takes+-- as an argument whether or not the reexporting package is exposed, and+-- also its 'UnitInfo'.+fromReexportedModules :: Bool -> UnitInfo -> ModuleOrigin+fromReexportedModules True pkg = ModOrigin Nothing [pkg] [] False+fromReexportedModules False pkg = ModOrigin Nothing [] [pkg] False++-- | Smart constructor for a module which was bound by a package flag.+fromFlag :: ModuleOrigin+fromFlag = ModOrigin Nothing [] [] True++instance Semigroup ModuleOrigin where+    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+    _x <> _y = panic "ModOrigin: hidden module redefined"++instance Monoid ModuleOrigin where+    mempty = ModOrigin Nothing [] [] False+    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?)+originVisible :: ModuleOrigin -> Bool+originVisible ModHidden = False+originVisible (ModUnusable _) = False+originVisible (ModOrigin b res _ f) = b == Just True || not (null res) || f++-- | Are there actually no providers for this module?  This will never occur+-- except when we're filtering based on package imports.+originEmpty :: ModuleOrigin -> Bool+originEmpty (ModOrigin Nothing [] [] False) = True+originEmpty _ = False++-- | 'UniqFM' map from 'InstalledUnitId'+type InstalledUnitIdMap = UniqDFM++-- | 'UniqFM' map from 'UnitId' to 'UnitInfo', plus+-- the transitive closure of preload packages.+data UnitInfoMap = UnitInfoMap {+        unUnitInfoMap :: InstalledUnitIdMap UnitInfo,+        -- | The set of transitively reachable packages according+        -- to the explicitly provided command line arguments.+        -- See Note [UnitId to InstalledUnitId improvement]+        preloadClosure :: UniqSet InstalledUnitId+    }++-- | 'UniqFM' map from 'UnitId' to a 'UnitVisibility'.+type VisibilityMap = Map UnitId UnitVisibility++-- | 'UnitVisibility' records the various aspects of visibility of a particular+-- 'UnitId'.+data UnitVisibility = UnitVisibility+    { uv_expose_all :: Bool+      --  ^ Should all modules in exposed-modules should be dumped into scope?+    , uv_renamings :: [(ModuleName, ModuleName)]+      -- ^ Any custom renamings that should bring extra 'ModuleName's into+      -- scope.+    , uv_package_name :: First FastString+      -- ^ The package name is associated with the 'UnitId'.  This is used+      -- to implement legacy behavior where @-package foo-0.1@ implicitly+      -- hides any packages named @foo@+    , uv_requirements :: Map ModuleName (Set IndefModule)+      -- ^ The signatures which are contributed to the requirements context+      -- from this unit ID.+    , uv_explicit :: Bool+      -- ^ Whether or not this unit was explicitly brought into scope,+      -- as opposed to implicitly via the 'exposed' fields in the+      -- package database (when @-hide-all-packages@ is not passed.)+    }++instance Outputable UnitVisibility where+    ppr (UnitVisibility {+        uv_expose_all = b,+        uv_renamings = rns,+        uv_package_name = First mb_pn,+        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+             , uv_renamings = []+             , uv_package_name = First Nothing+             , uv_requirements = Map.empty+             , uv_explicit = False+             }+    mappend = (Semigroup.<>)++type WiredUnitId = DefUnitId+type PreloadUnitId = InstalledUnitId++-- | Map from 'ModuleName' to a set of of module providers (i.e. a 'Module' and+-- its 'ModuleOrigin').+--+-- NB: the set is in fact a 'Map Module ModuleOrigin', probably to keep only one+-- origin for a given 'Module'+type ModuleNameProvidersMap =+    Map ModuleName (Map Module ModuleOrigin)++data PackageState = PackageState {+  -- | A mapping of 'UnitId' to 'UnitInfo'.  This list is adjusted+  -- so that only valid packages are here.  'UnitInfo' reflects+  -- what was stored *on disk*, except for the 'trusted' flag, which+  -- is adjusted at runtime.  (In particular, some packages in this map+  -- may have the 'exposed' flag be 'False'.)+  unitInfoMap :: UnitInfoMap,++  -- | A mapping of 'PackageName' to 'ComponentId'.  This is used when+  -- users refer to packages in Backpack includes.+  packageNameMap            :: Map PackageName ComponentId,++  -- | A mapping from wired in names to the original names from the+  -- package database.+  unwireMap :: Map WiredUnitId WiredUnitId,++  -- | The packages we're going to link in eagerly.  This list+  -- should be in reverse dependency order; that is, a package+  -- is always mentioned before the packages it depends on.+  preloadPackages      :: [PreloadUnitId],++  -- | Packages which we explicitly depend on (from a command line flag).+  -- We'll use this to generate version macros.+  explicitPackages      :: [UnitId],++  -- | This is a full map from 'ModuleName' to all modules which may possibly+  -- be providing it.  These providers may be hidden (but we'll still want+  -- to report them in error messages), or it may be an ambiguous import.+  moduleNameProvidersMap    :: !ModuleNameProvidersMap,++  -- | A map, like 'moduleNameProvidersMap', but controlling plugin visibility.+  pluginModuleNameProvidersMap    :: !ModuleNameProvidersMap,++  -- | A map saying, for each requirement, what interfaces must be merged+  -- together when we use them.  For example, if our dependencies+  -- are @p[A=<A>]@ and @q[A=<A>,B=r[C=<A>]:B]@, then the interfaces+  -- to merge for A are @p[A=<A>]:A@, @q[A=<A>,B=r[C=<A>]:B]:A@+  -- and @r[C=<A>]:C@.+  --+  -- There's an entry in this map for each hole in our home library.+  requirementContext :: Map ModuleName [IndefModule]+  }++emptyPackageState :: PackageState+emptyPackageState = PackageState {+    unitInfoMap = emptyUnitInfoMap,+    packageNameMap = Map.empty,+    unwireMap = Map.empty,+    preloadPackages = [],+    explicitPackages = [],+    moduleNameProvidersMap = Map.empty,+    pluginModuleNameProvidersMap = Map.empty,+    requirementContext = Map.empty+    }++-- | Package database+data PackageDatabase = PackageDatabase+   { packageDatabasePath  :: FilePath+   , packageDatabaseUnits :: [UnitInfo]+   }++type InstalledPackageIndex = Map InstalledUnitId UnitInfo++-- | Empty package configuration map+emptyUnitInfoMap :: UnitInfoMap+emptyUnitInfoMap = UnitInfoMap emptyUDFM emptyUniqSet++-- | Find the unit we know about with the given unit id, if any+lookupUnit :: DynFlags -> UnitId -> Maybe UnitInfo+lookupUnit dflags = lookupUnit' (isIndefinite dflags) (unitInfoMap (pkgState dflags))++-- | A more specialized interface, which takes a boolean specifying+-- whether or not to look for on-the-fly renamed interfaces, and+-- just a 'UnitInfoMap' rather than a 'DynFlags' (so it can+-- be used while we're initializing 'DynFlags'+lookupUnit' :: Bool -> UnitInfoMap -> UnitId -> Maybe UnitInfo+lookupUnit' False (UnitInfoMap pkg_map _) uid = lookupUDFM pkg_map uid+lookupUnit' True m@(UnitInfoMap pkg_map _) uid =+    case splitUnitIdInsts uid of+        (iuid, Just indef) ->+            fmap (renamePackage m (indefUnitIdInsts indef))+                 (lookupUDFM pkg_map iuid)+        (_, Nothing) -> lookupUDFM pkg_map uid++{-+-- | Find the indefinite package for a given 'ComponentId'.+-- The way this works is just by fiat'ing that every indefinite package's+-- unit key is precisely its component ID; and that they share uniques.+lookupComponentId :: DynFlags -> ComponentId -> Maybe UnitInfo+lookupComponentId dflags (ComponentId cid_fs) = lookupUDFM pkg_map cid_fs+  where+    UnitInfoMap pkg_map = unitInfoMap (pkgState dflags)+-}++-- | Find the package we know about with the given package name (e.g. @foo@), if any+-- (NB: there might be a locally defined unit name which overrides this)+lookupPackageName :: DynFlags -> PackageName -> Maybe ComponentId+lookupPackageName dflags n = Map.lookup n (packageNameMap (pkgState dflags))++-- | Search for packages with a given package ID (e.g. \"foo-0.1\")+searchPackageId :: DynFlags -> SourcePackageId -> [UnitInfo]+searchPackageId dflags pid = filter ((pid ==) . sourcePackageId)+                               (listUnitInfoMap dflags)++-- | Extends the package configuration map with a list of package configs.+extendUnitInfoMap+   :: UnitInfoMap -> [UnitInfo] -> UnitInfoMap+extendUnitInfoMap (UnitInfoMap pkg_map closure) new_pkgs+  = UnitInfoMap (foldl' add pkg_map new_pkgs) closure+    -- We also add the expanded version of the packageConfigId, so that+    -- 'improveUnitId' can find it.+  where add pkg_map p = addToUDFM (addToUDFM pkg_map (expandedUnitInfoId p) p)+                                  (installedUnitInfoId p) p++-- | Looks up the package with the given id in the package state, panicing if it is+-- not found+getPackageDetails :: HasDebugCallStack => DynFlags -> UnitId -> UnitInfo+getPackageDetails dflags pid =+    case lookupUnit dflags pid of+      Just config -> config+      Nothing -> pprPanic "getPackageDetails" (ppr pid)++lookupInstalledPackage :: DynFlags -> InstalledUnitId -> Maybe UnitInfo+lookupInstalledPackage dflags uid = lookupInstalledPackage' (unitInfoMap (pkgState dflags)) uid++lookupInstalledPackage' :: UnitInfoMap -> InstalledUnitId -> Maybe UnitInfo+lookupInstalledPackage' (UnitInfoMap db _) uid = lookupUDFM db uid++getInstalledPackageDetails :: HasDebugCallStack => DynFlags -> InstalledUnitId -> UnitInfo+getInstalledPackageDetails dflags uid =+    case lookupInstalledPackage dflags uid of+      Just config -> config+      Nothing -> pprPanic "getInstalledPackageDetails" (ppr uid)++-- | Get a list of entries from the package database.  NB: be careful with+-- this function, although all packages in this map are "visible", this+-- does not imply that the exposed-modules of the package are available+-- (they may have been thinned or renamed).+listUnitInfoMap :: DynFlags -> [UnitInfo]+listUnitInfoMap dflags = eltsUDFM pkg_map+  where+    UnitInfoMap pkg_map _ = unitInfoMap (pkgState dflags)++-- ----------------------------------------------------------------------------+-- Loading the package db files and building up the package state++-- | Read the package database files, and sets up various internal tables of+-- package information, according to the package-related flags on the+-- command-line (@-package@, @-hide-package@ etc.)+--+-- Returns a list of packages to link in if we're doing dynamic linking.+-- This list contains the packages that the user explicitly mentioned with+-- @-package@ flags.+--+-- 'initPackages' can be called again subsequently after updating the+-- 'packageFlags' field of the 'DynFlags', and it will update the+-- 'pkgState' in 'DynFlags' and return a list of packages to+-- link in.+initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId])+initPackages dflags = withTiming dflags+                                  (text "initializing package database")+                                  forcePkgDb $ do+  read_pkg_dbs <-+    case pkgDatabase dflags of+        Nothing  -> readPackageDatabases dflags+        Just dbs -> return dbs++  let+      distrust_all db = db { packageDatabaseUnits = distrustAllUnits (packageDatabaseUnits db) }++      pkg_dbs+         | gopt Opt_DistrustAllPackages dflags = map distrust_all read_pkg_dbs+         | otherwise                           = read_pkg_dbs++  (pkg_state, preload, insts)+        <- mkPackageState dflags pkg_dbs []+  return (dflags{ pkgDatabase = Just read_pkg_dbs,+                  pkgState = pkg_state,+                  thisUnitIdInsts_ = insts },+          preload)+  where+    forcePkgDb (dflags, _) = unitInfoMap (pkgState dflags) `seq` ()++-- -----------------------------------------------------------------------------+-- Reading the package database(s)++readPackageDatabases :: DynFlags -> IO [PackageDatabase]+readPackageDatabases dflags = do+  conf_refs <- getPackageConfRefs dflags+  confs     <- liftM catMaybes $ mapM (resolvePackageDatabase dflags) conf_refs+  mapM (readPackageDatabase dflags) confs+++getPackageConfRefs :: DynFlags -> IO [PkgDbRef]+getPackageConfRefs dflags = do+  let system_conf_refs = [UserPkgDb, GlobalPkgDb]++  e_pkg_path <- tryIO (getEnv $ map toUpper (programName dflags) ++ "_PACKAGE_PATH")+  let base_conf_refs = case e_pkg_path of+        Left _ -> system_conf_refs+        Right path+         | not (null path) && isSearchPathSeparator (last path)+         -> map PkgDbPath (splitSearchPath (init path)) ++ system_conf_refs+         | otherwise+         -> map PkgDbPath (splitSearchPath path)++  -- Apply the package DB-related flags from the command line to get the+  -- final list of package DBs.+  --+  -- Notes on ordering:+  --  * The list of flags is reversed (later ones first)+  --  * We work with the package DB list in "left shadows right" order+  --  * and finally reverse it at the end, to get "right shadows left"+  --+  return $ reverse (foldr doFlag base_conf_refs (packageDBFlags dflags))+ where+  doFlag (PackageDB p) dbs = p : dbs+  doFlag NoUserPackageDB dbs = filter isNotUser dbs+  doFlag NoGlobalPackageDB dbs = filter isNotGlobal dbs+  doFlag ClearPackageDBs _ = []++  isNotUser UserPkgDb = False+  isNotUser _ = True++  isNotGlobal GlobalPkgDb = False+  isNotGlobal _ = True++-- | Return the path of a package database from a 'PkgDbRef'. Return 'Nothing'+-- when the user database filepath is expected but the latter doesn't exist.+--+-- NB: This logic is reimplemented in Cabal, so if you change it,+-- make sure you update Cabal. (Or, better yet, dump it in the+-- compiler info so Cabal can use the info.)+resolvePackageDatabase :: DynFlags -> PkgDbRef -> IO (Maybe FilePath)+resolvePackageDatabase dflags GlobalPkgDb = return $ Just (globalPackageDatabasePath dflags)+resolvePackageDatabase dflags UserPkgDb = runMaybeT $ do+  dir <- versionedAppDir dflags+  let pkgconf = dir </> "package.conf.d"+  exist <- tryMaybeT $ doesDirectoryExist pkgconf+  if exist then return pkgconf else mzero+resolvePackageDatabase _ (PkgDbPath name) = return $ Just name++readPackageDatabase :: DynFlags -> FilePath -> IO PackageDatabase+readPackageDatabase dflags conf_file = do+  isdir <- doesDirectoryExist conf_file++  proto_pkg_configs <-+    if isdir+       then readDirStyleUnitInfo conf_file+       else do+            isfile <- doesFileExist conf_file+            if isfile+               then do+                 mpkgs <- tryReadOldFileStyleUnitInfo+                 case mpkgs of+                   Just pkgs -> return pkgs+                   Nothing   -> throwGhcExceptionIO $ InstallationError $+                      "ghc no longer supports single-file style package " +++                      "databases (" ++ conf_file +++                      ") use 'ghc-pkg init' to create the database with " +++                      "the correct format."+               else throwGhcExceptionIO $ InstallationError $+                      "can't find a package database at " ++ conf_file++  let+      -- Fix #16360: remove trailing slash from conf_file before calculating pkgroot+      conf_file' = dropTrailingPathSeparator conf_file+      top_dir = topDir dflags+      pkgroot = takeDirectory conf_file'+      pkg_configs1 = map (mungeUnitInfo top_dir pkgroot)+                         proto_pkg_configs+  --+  return $ PackageDatabase conf_file' pkg_configs1+  where+    readDirStyleUnitInfo conf_dir = do+      let filename = conf_dir </> "package.cache"+      cache_exists <- doesFileExist filename+      if cache_exists+        then do+          debugTraceMsg dflags 2 $ text "Using binary package database:"+                                    <+> text filename+          readPackageDbForGhc filename+        else do+          -- If there is no package.cache file, we check if the database is not+          -- empty by inspecting if the directory contains any .conf file. If it+          -- does, something is wrong and we fail. Otherwise we assume that the+          -- database is empty.+          debugTraceMsg dflags 2 $ text "There is no package.cache in"+                               <+> text conf_dir+                                <> text ", checking if the database is empty"+          db_empty <- all (not . isSuffixOf ".conf")+                   <$> getDirectoryContents conf_dir+          if db_empty+            then do+              debugTraceMsg dflags 3 $ text "There are no .conf files in"+                                   <+> text conf_dir <> text ", treating"+                                   <+> text "package database as empty"+              return []+            else do+              throwGhcExceptionIO $ InstallationError $+                "there is no package.cache in " ++ conf_dir +++                " even though package database is not empty"+++    -- Single-file style package dbs have been deprecated for some time, but+    -- it turns out that Cabal was using them in one place. So this is a+    -- workaround to allow older Cabal versions to use this newer ghc.+    -- We check if the file db contains just "[]" and if so, we look for a new+    -- dir-style db in conf_file.d/, ie in a dir next to the given file.+    -- We cannot just replace the file with a new dir style since Cabal still+    -- assumes it's a file and tries to overwrite with 'writeFile'.+    -- ghc-pkg also cooperates with this workaround.+    tryReadOldFileStyleUnitInfo = do+      content <- readFile conf_file `catchIO` \_ -> return ""+      if take 2 content == "[]"+        then do+          let conf_dir = conf_file <.> "d"+          direxists <- doesDirectoryExist conf_dir+          if direxists+             then do debugTraceMsg dflags 2 (text "Ignoring old file-style db and trying:" <+> text conf_dir)+                     liftM Just (readDirStyleUnitInfo conf_dir)+             else return (Just []) -- ghc-pkg will create it when it's updated+        else return Nothing++distrustAllUnits :: [UnitInfo] -> [UnitInfo]+distrustAllUnits pkgs = map distrust pkgs+  where+    distrust pkg = pkg{ trusted = False }++mungeUnitInfo :: FilePath -> FilePath+                   -> UnitInfo -> UnitInfo+mungeUnitInfo top_dir pkgroot =+    mungeDynLibFields+  . mungePackagePaths top_dir pkgroot++mungeDynLibFields :: UnitInfo -> UnitInfo+mungeDynLibFields pkg =+    pkg {+      libraryDynDirs     = libraryDynDirs pkg+                `orIfNull` libraryDirs pkg+    }+  where+    orIfNull [] flags = flags+    orIfNull flags _  = flags++-- TODO: This code is duplicated in utils/ghc-pkg/Main.hs+mungePackagePaths :: FilePath -> FilePath -> UnitInfo -> UnitInfo+-- Perform path/URL variable substitution as per the Cabal ${pkgroot} spec+-- (http://www.haskell.org/pipermail/libraries/2009-May/011772.html)+-- Paths/URLs can be relative to ${pkgroot} or ${pkgrooturl}.+-- The "pkgroot" is the directory containing the package database.+--+-- Also perform a similar substitution for the older GHC-specific+-- "$topdir" variable. The "topdir" is the location of the ghc+-- installation (obtained from the -B option).+mungePackagePaths top_dir pkgroot pkg =+    pkg {+      importDirs  = munge_paths (importDirs pkg),+      includeDirs = munge_paths (includeDirs pkg),+      libraryDirs = munge_paths (libraryDirs pkg),+      libraryDynDirs = munge_paths (libraryDynDirs pkg),+      frameworkDirs = munge_paths (frameworkDirs pkg),+      haddockInterfaces = munge_paths (haddockInterfaces pkg),+      haddockHTMLs = munge_urls (haddockHTMLs pkg)+    }+  where+    munge_paths = map munge_path+    munge_urls  = map munge_url++    munge_path p+      | Just p' <- stripVarPrefix "${pkgroot}" p = pkgroot ++ p'+      | Just p' <- stripVarPrefix "$topdir"    p = top_dir ++ p'+      | otherwise                                = p++    munge_url p+      | Just p' <- stripVarPrefix "${pkgrooturl}" p = toUrlPath pkgroot p'+      | Just p' <- stripVarPrefix "$httptopdir"   p = toUrlPath top_dir p'+      | otherwise                                   = p++    toUrlPath r p = "file:///"+                 -- URLs always use posix style '/' separators:+                 ++ FilePath.Posix.joinPath+                        (r : -- We need to drop a leading "/" or "\\"+                             -- if there is one:+                             dropWhile (all isPathSeparator)+                                       (FilePath.splitDirectories p))++    -- We could drop the separator here, and then use </> above. However,+    -- by leaving it in and using ++ we keep the same path separator+    -- rather than letting FilePath change it to use \ as the separator+    stripVarPrefix var path = case stripPrefix var path of+                              Just [] -> Just []+                              Just cs@(c : _) | isPathSeparator c -> Just cs+                              _ -> Nothing+++-- -----------------------------------------------------------------------------+-- Modify our copy of the package database based on trust flags,+-- -trust and -distrust.++applyTrustFlag+   :: DynFlags+   -> PackagePrecedenceIndex+   -> UnusablePackages+   -> [UnitInfo]+   -> TrustFlag+   -> IO [UnitInfo]+applyTrustFlag dflags prec_map unusable pkgs flag =+  case flag of+    -- we trust all matching packages. Maybe should only trust first one?+    -- and leave others the same or set them untrusted+    TrustPackage str ->+       case selectPackages prec_map (PackageArg str) pkgs unusable of+         Left ps       -> trustFlagErr dflags flag ps+         Right (ps,qs) -> return (map trust ps ++ qs)+          where trust p = p {trusted=True}++    DistrustPackage str ->+       case selectPackages prec_map (PackageArg str) pkgs unusable of+         Left ps       -> trustFlagErr dflags flag ps+         Right (ps,qs) -> return (distrustAllUnits ps ++ qs)++-- | A little utility to tell if the 'thisPackage' is indefinite+-- (if it is not, we should never use on-the-fly renaming.)+isIndefinite :: DynFlags -> Bool+isIndefinite dflags = not (unitIdIsDefinite (thisPackage dflags))++applyPackageFlag+   :: DynFlags+   -> PackagePrecedenceIndex+   -> UnitInfoMap+   -> UnusablePackages+   -> Bool -- if False, if you expose a package, it implicitly hides+           -- any previously exposed packages with the same name+   -> [UnitInfo]+   -> VisibilityMap           -- Initially exposed+   -> PackageFlag               -- flag to apply+   -> IO VisibilityMap        -- Now exposed++applyPackageFlag dflags prec_map pkg_db unusable no_hide_others pkgs vm flag =+  case flag of+    ExposePackage _ arg (ModRenaming b rns) ->+       case findPackages prec_map pkg_db arg pkgs unusable of+         Left ps         -> packageFlagErr dflags flag ps+         Right (p:_) -> return vm'+          where+           n = fsPackageName p++           -- If a user says @-unit-id p[A=<A>]@, this imposes+           -- a requirement on us: whatever our signature A is,+           -- it must fulfill all of p[A=<A>]:A's requirements.+           -- This method is responsible for computing what our+           -- inherited requirements are.+           reqs | UnitIdArg orig_uid <- arg = collectHoles orig_uid+                | otherwise                 = Map.empty++           collectHoles uid = case splitUnitIdInsts uid of+                (_, Just indef) ->+                  let local = [ Map.singleton+                                  (moduleName mod)+                                  (Set.singleton $ IndefModule indef mod_name)+                              | (mod_name, mod) <- indefUnitIdInsts indef+                              , isHoleModule mod ]+                      recurse = [ collectHoles (moduleUnitId mod)+                                | (_, mod) <- indefUnitIdInsts indef ]+                  in Map.unionsWith Set.union $ local ++ recurse+                -- Other types of unit identities don't have holes+                (_, Nothing) -> Map.empty+++           uv = UnitVisibility+                { uv_expose_all = b+                , uv_renamings = rns+                , uv_package_name = First (Just n)+                , uv_requirements = reqs+                , uv_explicit = True+                }+           vm' = Map.insertWith mappend (packageConfigId p) uv vm_cleared+           -- In the old days, if you said `ghc -package p-0.1 -package p-0.2`+           -- (or if p-0.1 was registered in the pkgdb as exposed: True),+           -- the second package flag would override the first one and you+           -- would only see p-0.2 in exposed modules.  This is good for+           -- usability.+           --+           -- However, with thinning and renaming (or Backpack), there might be+           -- situations where you legitimately want to see two versions of a+           -- package at the same time, and this behavior would make it+           -- impossible to do so.  So we decided that if you pass+           -- -hide-all-packages, this should turn OFF the overriding behavior+           -- where an exposed package hides all other packages with the same+           -- name.  This should not affect Cabal at all, which only ever+           -- exposes one package at a time.+           --+           -- NB: Why a variable no_hide_others?  We have to apply this logic to+           -- -plugin-package too, and it's more consistent if the switch in+           -- behavior is based off of+           -- -hide-all-packages/-hide-all-plugin-packages depending on what+           -- flag is in question.+           vm_cleared | no_hide_others = vm+                      -- NB: renamings never clear+                      | (_:_) <- rns = vm+                      | otherwise = Map.filterWithKey+                            (\k uv -> k == packageConfigId p+                                   || First (Just n) /= uv_package_name uv) vm+         _ -> panic "applyPackageFlag"++    HidePackage str ->+       case findPackages prec_map pkg_db (PackageArg str) pkgs unusable of+         Left ps  -> packageFlagErr dflags flag ps+         Right ps -> return vm'+          where vm' = foldl' (flip Map.delete) vm (map packageConfigId ps)++-- | Like 'selectPackages', but doesn't return a list of unmatched+-- packages.  Furthermore, any packages it returns are *renamed*+-- if the 'UnitArg' has a renaming associated with it.+findPackages :: PackagePrecedenceIndex+             -> UnitInfoMap -> PackageArg -> [UnitInfo]+             -> UnusablePackages+             -> Either [(UnitInfo, UnusablePackageReason)]+                [UnitInfo]+findPackages prec_map pkg_db arg pkgs unusable+  = let ps = mapMaybe (finder arg) pkgs+    in if null ps+        then Left (mapMaybe (\(x,y) -> finder arg x >>= \x' -> return (x',y))+                            (Map.elems unusable))+        else Right (sortByPreference prec_map ps)+  where+    finder (PackageArg str) p+      = if str == sourcePackageIdString p || str == packageNameString p+          then Just p+          else Nothing+    finder (UnitIdArg uid) p+      = let (iuid, mb_indef) = splitUnitIdInsts uid+        in if iuid == installedUnitInfoId p+              then Just (case mb_indef of+                            Nothing    -> p+                            Just indef -> renamePackage pkg_db (indefUnitIdInsts indef) p)+              else Nothing++selectPackages :: PackagePrecedenceIndex -> PackageArg -> [UnitInfo]+               -> UnusablePackages+               -> Either [(UnitInfo, UnusablePackageReason)]+                  ([UnitInfo], [UnitInfo])+selectPackages prec_map arg pkgs unusable+  = let matches = matching arg+        (ps,rest) = partition matches pkgs+    in if null ps+        then Left (filter (matches.fst) (Map.elems unusable))+        else Right (sortByPreference prec_map ps, rest)++-- | Rename a 'UnitInfo' according to some module instantiation.+renamePackage :: UnitInfoMap -> [(ModuleName, Module)]+              -> UnitInfo -> UnitInfo+renamePackage pkg_map insts conf =+    let hsubst = listToUFM insts+        smod  = renameHoleModule' pkg_map hsubst+        new_insts = map (\(k,v) -> (k,smod v)) (instantiatedWith conf)+    in conf {+        instantiatedWith = new_insts,+        exposedModules = map (\(mod_name, mb_mod) -> (mod_name, fmap smod mb_mod))+                             (exposedModules conf)+    }+++-- A package named on the command line can either include the+-- version, or just the name if it is unambiguous.+matchingStr :: String -> UnitInfo -> Bool+matchingStr str p+        =  str == sourcePackageIdString p+        || str == packageNameString p++matchingId :: InstalledUnitId -> UnitInfo -> Bool+matchingId uid p = uid == installedUnitInfoId p++matching :: PackageArg -> UnitInfo -> Bool+matching (PackageArg str) = matchingStr str+matching (UnitIdArg (DefiniteUnitId (DefUnitId uid)))  = matchingId uid+matching (UnitIdArg _)  = \_ -> False -- TODO: warn in this case++-- | This sorts a list of packages, putting "preferred" packages first.+-- See 'compareByPreference' for the semantics of "preference".+sortByPreference :: PackagePrecedenceIndex -> [UnitInfo] -> [UnitInfo]+sortByPreference prec_map = sortBy (flip (compareByPreference prec_map))++-- | Returns 'GT' if @pkg@ should be preferred over @pkg'@ when picking+-- which should be "active".  Here is the order of preference:+--+--      1. First, prefer the latest version+--      2. If the versions are the same, prefer the package that+--      came in the latest package database.+--+-- Pursuant to #12518, we could change this policy to, for example, remove+-- the version preference, meaning that we would always prefer the packages+-- in later package database.+--+-- Instead, we use that preference based policy only when one of the packages+-- is integer-gmp and the other is integer-simple.+-- This currently only happens when we're looking up which concrete+-- package to use in place of @integer-wired-in@ and that two different+-- package databases supply a different integer library. For more about+-- the fake @integer-wired-in@ package, see Note [The integer library]+-- in the @PrelNames@ module.+compareByPreference+    :: PackagePrecedenceIndex+    -> UnitInfo+    -> UnitInfo+    -> Ordering+compareByPreference prec_map pkg pkg'+  | Just prec  <- Map.lookup (unitId pkg)  prec_map+  , Just prec' <- Map.lookup (unitId pkg') prec_map+  , differentIntegerPkgs pkg pkg'+  = compare prec prec'++  | otherwise+  = case comparing packageVersion pkg pkg' of+        GT -> GT+        EQ | Just prec  <- Map.lookup (unitId pkg)  prec_map+           , Just prec' <- Map.lookup (unitId pkg') prec_map+           -- Prefer the package from the later DB flag (i.e., higher+           -- precedence)+           -> compare prec prec'+           | otherwise+           -> EQ+        LT -> LT++  where isIntegerPkg p = packageNameString p `elem`+          ["integer-simple", "integer-gmp"]+        differentIntegerPkgs p p' =+          isIntegerPkg p && isIntegerPkg p' &&+          (packageName p /= packageName p')++comparing :: Ord a => (t -> a) -> t -> t -> Ordering+comparing f a b = f a `compare` f b++packageFlagErr :: DynFlags+               -> PackageFlag+               -> [(UnitInfo, UnusablePackageReason)]+               -> IO a+packageFlagErr dflags flag reasons+  = packageFlagErr' dflags (pprFlag flag) reasons++trustFlagErr :: DynFlags+             -> TrustFlag+             -> [(UnitInfo, UnusablePackageReason)]+             -> IO a+trustFlagErr dflags flag reasons+  = packageFlagErr' dflags (pprTrustFlag flag) reasons++packageFlagErr' :: DynFlags+               -> SDoc+               -> [(UnitInfo, UnusablePackageReason)]+               -> IO a+packageFlagErr' dflags flag_doc reasons+  = throwGhcExceptionIO (CmdLineError (showSDoc dflags $ err))+  where err = text "cannot satisfy " <> flag_doc <>+                (if null reasons then Outputable.empty else text ": ") $$+              nest 4 (ppr_reasons $$+                      text "(use -v for more information)")+        ppr_reasons = vcat (map ppr_reason reasons)+        ppr_reason (p, reason) =+            pprReason (ppr (unitId p) <+> text "is") reason++pprFlag :: PackageFlag -> SDoc+pprFlag flag = case flag of+    HidePackage p   -> text "-hide-package " <> text p+    ExposePackage doc _ _ -> text doc++pprTrustFlag :: TrustFlag -> SDoc+pprTrustFlag flag = case flag of+    TrustPackage p    -> text "-trust " <> text p+    DistrustPackage p -> text "-distrust " <> text p++-- -----------------------------------------------------------------------------+-- Wired-in packages+--+-- See Note [Wired-in packages] in Module++type WiredInUnitId = String+type WiredPackagesMap = Map WiredUnitId WiredUnitId++wired_in_unitids :: [WiredInUnitId]+wired_in_unitids = map unitIdString wiredInUnitIds++findWiredInPackages+   :: DynFlags+   -> PackagePrecedenceIndex+   -> [UnitInfo]           -- database+   -> VisibilityMap             -- info on what packages are visible+                                -- for wired in selection+   -> IO ([UnitInfo],  -- package database updated for wired in+          WiredPackagesMap) -- map from unit id to wired identity++findWiredInPackages dflags prec_map pkgs vis_map = do+  -- Now we must find our wired-in packages, and rename them to+  -- their canonical names (eg. base-1.0 ==> base), as described+  -- in Note [Wired-in packages] in Module+  let+        matches :: UnitInfo -> WiredInUnitId -> Bool+        pc `matches` pid+            -- See Note [The integer library] in PrelNames+            | pid == unitIdString integerUnitId+            = packageNameString pc `elem` ["integer-gmp", "integer-simple"]+        pc `matches` pid = packageNameString pc == pid++        -- find which package corresponds to each wired-in package+        -- delete any other packages with the same name+        -- update the package and any dependencies to point to the new+        -- one.+        --+        -- When choosing which package to map to a wired-in package+        -- name, we try to pick the latest version of exposed packages.+        -- However, if there are no exposed wired in packages available+        -- (e.g. -hide-all-packages was used), we can't bail: we *have*+        -- to assign a package for the wired-in package: so we try again+        -- with hidden packages included to (and pick the latest+        -- version).+        --+        -- You can also override the default choice by using -ignore-package:+        -- this works even when there is no exposed wired in package+        -- available.+        --+        findWiredInPackage :: [UnitInfo] -> WiredInUnitId+                           -> IO (Maybe (WiredInUnitId, UnitInfo))+        findWiredInPackage pkgs wired_pkg =+           let all_ps = [ p | p <- pkgs, p `matches` wired_pkg ]+               all_exposed_ps =+                    [ p | p <- all_ps+                        , Map.member (packageConfigId p) vis_map ] in+           case all_exposed_ps of+            [] -> case all_ps of+                       []   -> notfound+                       many -> pick (head (sortByPreference prec_map many))+            many -> pick (head (sortByPreference prec_map many))+          where+                notfound = do+                          debugTraceMsg dflags 2 $+                            text "wired-in package "+                                 <> text wired_pkg+                                 <> text " not found."+                          return Nothing+                pick :: UnitInfo+                     -> IO (Maybe (WiredInUnitId, UnitInfo))+                pick pkg = do+                        debugTraceMsg dflags 2 $+                            text "wired-in package "+                                 <> text wired_pkg+                                 <> text " mapped to "+                                 <> ppr (unitId pkg)+                        return (Just (wired_pkg, pkg))+++  mb_wired_in_pkgs <- mapM (findWiredInPackage pkgs) wired_in_unitids+  let+        wired_in_pkgs = catMaybes mb_wired_in_pkgs++        -- this is old: we used to assume that if there were+        -- multiple versions of wired-in packages installed that+        -- they were mutually exclusive.  Now we're assuming that+        -- you have one "main" version of each wired-in package+        -- (the latest version), and the others are backward-compat+        -- wrappers that depend on this one.  e.g. base-4.0 is the+        -- latest, base-3.0 is a compat wrapper depending on base-4.0.+        {-+        deleteOtherWiredInPackages pkgs = filterOut bad pkgs+          where bad p = any (p `matches`) wired_in_unitids+                      && package p `notElem` map fst wired_in_ids+        -}++        wiredInMap :: Map WiredUnitId WiredUnitId+        wiredInMap = Map.fromList+          [ (key, DefUnitId (stringToInstalledUnitId wiredInUnitId))+          | (wiredInUnitId, pkg) <- wired_in_pkgs+          , Just key <- pure $ definiteUnitInfoId pkg+          ]++        updateWiredInDependencies pkgs = map (upd_deps . upd_pkg) pkgs+          where upd_pkg pkg+                  | Just def_uid <- definiteUnitInfoId pkg+                  , Just wiredInUnitId <- Map.lookup def_uid wiredInMap+                  = let fs = installedUnitIdFS (unDefUnitId wiredInUnitId)+                    in pkg {+                      unitId = fsToInstalledUnitId fs,+                      componentId = ComponentId fs+                    }+                  | otherwise+                  = pkg+                upd_deps pkg = pkg {+                      -- temporary harmless DefUnitId invariant violation+                      depends = map (unDefUnitId . upd_wired_in wiredInMap . DefUnitId) (depends pkg),+                      exposedModules+                        = map (\(k,v) -> (k, fmap (upd_wired_in_mod wiredInMap) v))+                              (exposedModules pkg)+                    }+++  return (updateWiredInDependencies pkgs, wiredInMap)++-- Helper functions for rewiring Module and UnitId.  These+-- rewrite UnitIds of modules in wired-in packages to the form known to the+-- compiler, as described in Note [Wired-in packages] in Module.+--+-- For instance, base-4.9.0.0 will be rewritten to just base, to match+-- what appears in PrelNames.++upd_wired_in_mod :: WiredPackagesMap -> Module -> Module+upd_wired_in_mod wiredInMap (Module uid m) = Module (upd_wired_in_uid wiredInMap uid) m++upd_wired_in_uid :: WiredPackagesMap -> UnitId -> UnitId+upd_wired_in_uid wiredInMap (DefiniteUnitId def_uid) =+    DefiniteUnitId (upd_wired_in wiredInMap def_uid)+upd_wired_in_uid wiredInMap (IndefiniteUnitId indef_uid) =+    IndefiniteUnitId $ newIndefUnitId+        (indefUnitIdComponentId indef_uid)+        (map (\(x,y) -> (x,upd_wired_in_mod wiredInMap y)) (indefUnitIdInsts indef_uid))++upd_wired_in :: WiredPackagesMap -> DefUnitId -> DefUnitId+upd_wired_in wiredInMap key+    | Just key' <- Map.lookup key wiredInMap = key'+    | otherwise = key++updateVisibilityMap :: WiredPackagesMap -> VisibilityMap -> VisibilityMap+updateVisibilityMap wiredInMap vis_map = foldl' f vis_map (Map.toList wiredInMap)+  where f vm (from, to) = case Map.lookup (DefiniteUnitId from) vis_map of+                    Nothing -> vm+                    Just r -> Map.insert (DefiniteUnitId to) r+                                (Map.delete (DefiniteUnitId from) vm)+++-- ----------------------------------------------------------------------------++-- | The reason why a package is unusable.+data UnusablePackageReason+  = -- | We ignored it explicitly using @-ignore-package@.+    IgnoredWithFlag+    -- | This package transitively depends on a package that was never present+    -- in any of the provided databases.+  | BrokenDependencies   [InstalledUnitId]+    -- | This package transitively depends on a package involved in a cycle.+    -- Note that the list of 'InstalledUnitId' reports the direct dependencies+    -- of this package that (transitively) depended on the cycle, and not+    -- the actual cycle itself (which we report separately at high verbosity.)+  | CyclicDependencies   [InstalledUnitId]+    -- | This package transitively depends on a package which was ignored.+  | IgnoredDependencies  [InstalledUnitId]+    -- | This package transitively depends on a package which was+    -- shadowed by an ABI-incompatible package.+  | ShadowedDependencies [InstalledUnitId]++instance Outputable UnusablePackageReason where+    ppr IgnoredWithFlag = text "[ignored with flag]"+    ppr (BrokenDependencies uids)   = brackets (text "broken" <+> ppr uids)+    ppr (CyclicDependencies uids)   = brackets (text "cyclic" <+> ppr uids)+    ppr (IgnoredDependencies uids)  = brackets (text "ignored" <+> ppr uids)+    ppr (ShadowedDependencies uids) = brackets (text "shadowed" <+> ppr uids)++type UnusablePackages = Map InstalledUnitId+                            (UnitInfo, UnusablePackageReason)++pprReason :: SDoc -> UnusablePackageReason -> SDoc+pprReason pref reason = case reason of+  IgnoredWithFlag ->+      pref <+> text "ignored due to an -ignore-package flag"+  BrokenDependencies deps ->+      pref <+> text "unusable due to missing dependencies:" $$+        nest 2 (hsep (map ppr deps))+  CyclicDependencies deps ->+      pref <+> text "unusable due to cyclic dependencies:" $$+        nest 2 (hsep (map ppr deps))+  IgnoredDependencies deps ->+      pref <+> text ("unusable because the -ignore-package flag was used to " +++                     "ignore at least one of its dependencies:") $$+        nest 2 (hsep (map ppr deps))+  ShadowedDependencies deps ->+      pref <+> text "unusable due to shadowed dependencies:" $$+        nest 2 (hsep (map ppr deps))++reportCycles :: DynFlags -> [SCC UnitInfo] -> IO ()+reportCycles dflags sccs = mapM_ report sccs+  where+    report (AcyclicSCC _) = return ()+    report (CyclicSCC vs) =+        debugTraceMsg dflags 2 $+          text "these packages are involved in a cycle:" $$+            nest 2 (hsep (map (ppr . unitId) vs))++reportUnusable :: DynFlags -> UnusablePackages -> IO ()+reportUnusable dflags pkgs = mapM_ report (Map.toList pkgs)+  where+    report (ipid, (_, reason)) =+       debugTraceMsg dflags 2 $+         pprReason+           (text "package" <+> ppr ipid <+> text "is") reason++-- ----------------------------------------------------------------------------+--+-- Utilities on the database+--++-- | A reverse dependency index, mapping an 'InstalledUnitId' to+-- the 'InstalledUnitId's which have a dependency on it.+type RevIndex = Map InstalledUnitId [InstalledUnitId]++-- | Compute the reverse dependency index of a package database.+reverseDeps :: InstalledPackageIndex -> RevIndex+reverseDeps db = Map.foldl' go Map.empty db+  where+    go r pkg = foldl' (go' (unitId pkg)) r (depends pkg)+    go' from r to = Map.insertWith (++) to [from] r++-- | Given a list of 'InstalledUnitId's to remove, a database,+-- and a reverse dependency index (as computed by 'reverseDeps'),+-- remove those packages, plus any packages which depend on them.+-- Returns the pruned database, as well as a list of 'UnitInfo's+-- that was removed.+removePackages :: [InstalledUnitId] -> RevIndex+               -> InstalledPackageIndex+               -> (InstalledPackageIndex, [UnitInfo])+removePackages uids index m = go uids (m,[])+  where+    go [] (m,pkgs) = (m,pkgs)+    go (uid:uids) (m,pkgs)+        | Just pkg <- Map.lookup uid m+        = case Map.lookup uid index of+            Nothing    -> go uids (Map.delete uid m, pkg:pkgs)+            Just rdeps -> go (rdeps ++ uids) (Map.delete uid m, pkg:pkgs)+        | otherwise+        = go uids (m,pkgs)++-- | Given a 'UnitInfo' from some 'InstalledPackageIndex',+-- return all entries in 'depends' which correspond to packages+-- that do not exist in the index.+depsNotAvailable :: InstalledPackageIndex+                 -> UnitInfo+                 -> [InstalledUnitId]+depsNotAvailable pkg_map pkg = filter (not . (`Map.member` pkg_map)) (depends pkg)++-- | Given a 'UnitInfo' from some 'InstalledPackageIndex'+-- return all entries in 'abiDepends' which correspond to packages+-- that do not exist, OR have mismatching ABIs.+depsAbiMismatch :: InstalledPackageIndex+                -> UnitInfo+                -> [InstalledUnitId]+depsAbiMismatch pkg_map pkg = map fst . filter (not . abiMatch) $ abiDepends pkg+  where+    abiMatch (dep_uid, abi)+        | Just dep_pkg <- Map.lookup dep_uid pkg_map+        = abiHash dep_pkg == abi+        | otherwise+        = False++-- -----------------------------------------------------------------------------+-- Ignore packages++ignorePackages :: [IgnorePackageFlag] -> [UnitInfo] -> UnusablePackages+ignorePackages flags pkgs = Map.fromList (concatMap doit flags)+  where+  doit (IgnorePackage str) =+     case partition (matchingStr str) pkgs of+         (ps, _) -> [ (unitId p, (p, IgnoredWithFlag))+                    | p <- ps ]+        -- missing package is not an error for -ignore-package,+        -- because a common usage is to -ignore-package P as+        -- a preventative measure just in case P exists.++-- ----------------------------------------------------------------------------+--+-- Merging databases+--++-- | For each package, a mapping from uid -> i indicates that this+-- package was brought into GHC by the ith @-package-db@ flag on+-- the command line.  We use this mapping to make sure we prefer+-- packages that were defined later on the command line, if there+-- is an ambiguity.+type PackagePrecedenceIndex = Map InstalledUnitId Int++-- | Given a list of databases, merge them together, where+-- packages with the same unit id in later databases override+-- earlier ones.  This does NOT check if the resulting database+-- makes sense (that's done by 'validateDatabase').+mergeDatabases :: DynFlags -> [PackageDatabase]+               -> IO (InstalledPackageIndex, PackagePrecedenceIndex)+mergeDatabases dflags = foldM merge (Map.empty, Map.empty) . zip [1..]+  where+    merge (pkg_map, prec_map) (i, PackageDatabase db_path db) = do+      debugTraceMsg dflags 2 $+          text "loading package database" <+> text db_path+      forM_ (Set.toList override_set) $ \pkg ->+          debugTraceMsg dflags 2 $+              text "package" <+> ppr pkg <+>+              text "overrides a previously defined package"+      return (pkg_map', prec_map')+     where+      db_map = mk_pkg_map db+      mk_pkg_map = Map.fromList . map (\p -> (unitId p, p))++      -- The set of UnitIds which appear in both db and pkgs.  These are the+      -- ones that get overridden.  Compute this just to give some+      -- helpful debug messages at -v2+      override_set :: Set InstalledUnitId+      override_set = Set.intersection (Map.keysSet db_map)+                                      (Map.keysSet pkg_map)++      -- Now merge the sets together (NB: in case of duplicate,+      -- first argument preferred)+      pkg_map' :: InstalledPackageIndex+      pkg_map' = Map.union db_map pkg_map++      prec_map' :: PackagePrecedenceIndex+      prec_map' = Map.union (Map.map (const i) db_map) prec_map++-- | Validates a database, removing unusable packages from it+-- (this includes removing packages that the user has explicitly+-- ignored.)  Our general strategy:+--+-- 1. Remove all broken packages (dangling dependencies)+-- 2. Remove all packages that are cyclic+-- 3. Apply ignore flags+-- 4. Remove all packages which have deps with mismatching ABIs+--+validateDatabase :: DynFlags -> InstalledPackageIndex+                 -> (InstalledPackageIndex, UnusablePackages, [SCC UnitInfo])+validateDatabase dflags pkg_map1 =+    (pkg_map5, unusable, sccs)+  where+    ignore_flags = reverse (ignorePackageFlags dflags)++    -- Compute the reverse dependency index+    index = reverseDeps pkg_map1++    -- Helper function+    mk_unusable mk_err dep_matcher m uids =+      Map.fromList [ (unitId pkg, (pkg, mk_err (dep_matcher m pkg)))+                   | pkg <- uids ]++    -- Find broken packages+    directly_broken = filter (not . null . depsNotAvailable pkg_map1)+                             (Map.elems pkg_map1)+    (pkg_map2, broken) = removePackages (map unitId directly_broken) index pkg_map1+    unusable_broken = mk_unusable BrokenDependencies depsNotAvailable pkg_map2 broken++    -- Find recursive packages+    sccs = stronglyConnComp [ (pkg, unitId pkg, depends pkg)+                            | pkg <- Map.elems pkg_map2 ]+    getCyclicSCC (CyclicSCC vs) = map unitId vs+    getCyclicSCC (AcyclicSCC _) = []+    (pkg_map3, cyclic) = removePackages (concatMap getCyclicSCC sccs) index pkg_map2+    unusable_cyclic = mk_unusable CyclicDependencies depsNotAvailable pkg_map3 cyclic++    -- Apply ignore flags+    directly_ignored = ignorePackages ignore_flags (Map.elems pkg_map3)+    (pkg_map4, ignored) = removePackages (Map.keys directly_ignored) index pkg_map3+    unusable_ignored = mk_unusable IgnoredDependencies depsNotAvailable pkg_map4 ignored++    -- Knock out packages whose dependencies don't agree with ABI+    -- (i.e., got invalidated due to shadowing)+    directly_shadowed = filter (not . null . depsAbiMismatch pkg_map4)+                               (Map.elems pkg_map4)+    (pkg_map5, shadowed) = removePackages (map unitId directly_shadowed) index pkg_map4+    unusable_shadowed = mk_unusable ShadowedDependencies depsAbiMismatch pkg_map5 shadowed++    unusable = directly_ignored `Map.union` unusable_ignored+                                `Map.union` unusable_broken+                                `Map.union` unusable_cyclic+                                `Map.union` unusable_shadowed++-- -----------------------------------------------------------------------------+-- When all the command-line options are in, we can process our package+-- settings and populate the package state.++mkPackageState+    :: DynFlags+    -- initial databases, in the order they were specified on+    -- the command line (later databases shadow earlier ones)+    -> [PackageDatabase]+    -> [PreloadUnitId]              -- preloaded packages+    -> IO (PackageState,+           [PreloadUnitId],         -- new packages to preload+           Maybe [(ModuleName, Module)])++mkPackageState dflags dbs preload0 = do+{-+   Plan.++   There are two main steps for making the package state:++    1. We want to build a single, unified package database based+       on all of the input databases, which upholds the invariant that+       there is only one package per any UnitId and there are no+       dangling dependencies.  We'll do this by merging, and+       then successively filtering out bad dependencies.++       a) Merge all the databases together.+          If an input database defines unit ID that is already in+          the unified database, that package SHADOWS the existing+          package in the current unified database.  Note that+          order is important: packages defined later in the list of+          command line arguments shadow those defined earlier.++       b) Remove all packages with missing dependencies, or+          mutually recursive dependencies.++       b) Remove packages selected by -ignore-package from input database++       c) Remove all packages which depended on packages that are now+          shadowed by an ABI-incompatible package++       d) report (with -v) any packages that were removed by steps 1-3++    2. We want to look at the flags controlling package visibility,+       and build a mapping of what module names are in scope and+       where they live.++       a) on the final, unified database, we apply -trust/-distrust+          flags directly, modifying the database so that the 'trusted'+          field has the correct value.++       b) we use the -package/-hide-package flags to compute a+          visibility map, stating what packages are "exposed" for+          the purposes of computing the module map.+          * if any flag refers to a package which was removed by 1-5, then+            we can give an error message explaining why+          * if -hide-all-packages was not specified, this step also+            hides packages which are superseded by later exposed packages+          * this step is done TWICE if -plugin-package/-hide-all-plugin-packages+            are used++       c) based on the visibility map, we pick wired packages and rewrite+          them to have the expected unitId.++       d) finally, using the visibility map and the package database,+          we build a mapping saying what every in scope module name points to.+-}++  -- This, and the other reverse's that you will see, are due to the fact that+  -- packageFlags, pluginPackageFlags, etc. are all specified in *reverse* order+  -- than they are on the command line.+  let other_flags = reverse (packageFlags dflags)+  debugTraceMsg dflags 2 $+      text "package flags" <+> ppr other_flags++  -- Merge databases together, without checking validity+  (pkg_map1, prec_map) <- mergeDatabases dflags dbs++  -- Now that we've merged everything together, prune out unusable+  -- packages.+  let (pkg_map2, unusable, sccs) = validateDatabase dflags pkg_map1++  reportCycles dflags sccs+  reportUnusable dflags unusable++  -- Apply trust flags (these flags apply regardless of whether+  -- or not packages are visible or not)+  pkgs1 <- foldM (applyTrustFlag dflags prec_map unusable)+                 (Map.elems pkg_map2) (reverse (trustFlags dflags))+  let prelim_pkg_db = extendUnitInfoMap emptyUnitInfoMap pkgs1++  --+  -- Calculate the initial set of units from package databases, prior to any package flags.+  --+  -- Conceptually, we select the latest versions of all valid (not unusable) *packages*+  -- (not units). This is empty if we have -hide-all-packages.+  --+  -- Then we create an initial visibility map with default visibilities for all+  -- exposed, definite units which belong to the latest valid packages.+  --+  let preferLater unit unit' =+        case compareByPreference prec_map unit unit' of+            GT -> unit+            _  -> unit'+      addIfMorePreferable m unit = addToUDFM_C preferLater m (fsPackageName unit) unit+      -- This is the set of maximally preferable packages. In fact, it is a set of+      -- most preferable *units* keyed by package name, which act as stand-ins in+      -- for "a package in a database". We use units here because we don't have+      -- "a package in a database" as a type currently.+      mostPreferablePackageReps = if gopt Opt_HideAllPackages dflags+                    then emptyUDFM+                    else foldl' addIfMorePreferable emptyUDFM pkgs1+      -- When exposing units, we want to consider all of those in the most preferable+      -- packages. We can implement that by looking for units that are equi-preferable+      -- with the most preferable unit for package. Being equi-preferable means that+      -- they must be in the same database, with the same version, and the same package name.+      --+      -- We must take care to consider all these units and not just the most+      -- preferable one, otherwise we can end up with problems like #16228.+      mostPreferable u =+        case lookupUDFM mostPreferablePackageReps (fsPackageName u) of+          Nothing -> False+          Just u' -> compareByPreference prec_map u u' == EQ+      vis_map1 = foldl' (\vm p ->+                            -- Note: we NEVER expose indefinite packages by+                            -- default, because it's almost assuredly not+                            -- what you want (no mix-in linking has occurred).+                            if exposed p && unitIdIsDefinite (packageConfigId p) && mostPreferable p+                               then Map.insert (packageConfigId p)+                                               UnitVisibility {+                                                 uv_expose_all = True,+                                                 uv_renamings = [],+                                                 uv_package_name = First (Just (fsPackageName p)),+                                                 uv_requirements = Map.empty,+                                                 uv_explicit = False+                                               }+                                               vm+                               else vm)+                         Map.empty pkgs1++  --+  -- Compute a visibility map according to the command-line flags (-package,+  -- -hide-package).  This needs to know about the unusable packages, since if a+  -- user tries to enable an unusable package, we should let them know.+  --+  vis_map2 <- foldM (applyPackageFlag dflags prec_map prelim_pkg_db unusable+                        (gopt Opt_HideAllPackages dflags) pkgs1)+                            vis_map1 other_flags++  --+  -- Sort out which packages are wired in. This has to be done last, since+  -- it modifies the unit ids of wired in packages, but when we process+  -- package arguments we need to key against the old versions.+  --+  (pkgs2, wired_map) <- findWiredInPackages dflags prec_map pkgs1 vis_map2+  let pkg_db = extendUnitInfoMap emptyUnitInfoMap pkgs2++  -- Update the visibility map, so we treat wired packages as visible.+  let vis_map = updateVisibilityMap wired_map vis_map2++  let hide_plugin_pkgs = gopt Opt_HideAllPluginPackages dflags+  plugin_vis_map <-+    case pluginPackageFlags dflags of+        -- common case; try to share the old vis_map+        [] | not hide_plugin_pkgs -> return vis_map+           | otherwise -> return Map.empty+        _ -> do let plugin_vis_map1+                        | hide_plugin_pkgs = Map.empty+                        -- Use the vis_map PRIOR to wired in,+                        -- because otherwise applyPackageFlag+                        -- won't work.+                        | otherwise = vis_map2+                plugin_vis_map2+                    <- foldM (applyPackageFlag dflags prec_map prelim_pkg_db unusable+                                (gopt Opt_HideAllPluginPackages dflags) pkgs1)+                             plugin_vis_map1+                             (reverse (pluginPackageFlags dflags))+                -- Updating based on wired in packages is mostly+                -- good hygiene, because it won't matter: no wired in+                -- package has a compiler plugin.+                -- TODO: If a wired in package had a compiler plugin,+                -- and you tried to pick different wired in packages+                -- with the plugin flags and the normal flags... what+                -- would happen?  I don't know!  But this doesn't seem+                -- likely to actually happen.+                return (updateVisibilityMap wired_map plugin_vis_map2)++  --+  -- Here we build up a set of the packages mentioned in -package+  -- flags on the command line; these are called the "preload"+  -- packages.  we link these packages in eagerly.  The preload set+  -- should contain at least rts & base, which is why we pretend that+  -- the command line contains -package rts & -package base.+  --+  -- NB: preload IS important even for type-checking, because we+  -- need the correct include path to be set.+  --+  let preload1 = Map.keys (Map.filter uv_explicit vis_map)++  let pkgname_map = foldl' add Map.empty pkgs2+        where add pn_map p+                = Map.insert (packageName p) (componentId p) pn_map++  -- The explicitPackages accurately reflects the set of packages we have turned+  -- on; as such, it also is the only way one can come up with requirements.+  -- The requirement context is directly based off of this: we simply+  -- look for nested unit IDs that are directly fed holes: the requirements+  -- of those units are precisely the ones we need to track+  let explicit_pkgs = Map.keys vis_map+      req_ctx = Map.map (Set.toList)+              $ Map.unionsWith Set.union (map uv_requirements (Map.elems vis_map))+++  let preload2 = preload1++  let+      -- add base & rts to the preload packages+      basicLinkedPackages+       | gopt Opt_AutoLinkPackages dflags+          = filter (flip elemUDFM (unUnitInfoMap pkg_db))+                [baseUnitId, rtsUnitId]+       | otherwise = []+      -- but in any case remove the current package from the set of+      -- preloaded packages so that base/rts does not end up in the+      -- set up preloaded package when we are just building it+      -- (NB: since this is only relevant for base/rts it doesn't matter+      -- that thisUnitIdInsts_ is not wired yet)+      --+      preload3 = ordNub $ filter (/= thisPackage dflags)+                        $ (basicLinkedPackages ++ preload2)++  -- Close the preload packages with their dependencies+  dep_preload <- closeDeps dflags pkg_db (zip (map toInstalledUnitId preload3) (repeat Nothing))+  let new_dep_preload = filter (`notElem` preload0) dep_preload++  let mod_map1 = mkModuleNameProvidersMap dflags pkg_db vis_map+      mod_map2 = mkUnusableModuleNameProvidersMap unusable+      mod_map = Map.union mod_map1 mod_map2++  dumpIfSet_dyn (dflags { pprCols = 200 }) Opt_D_dump_mod_map "Mod Map"+    FormatText+    (pprModuleMap mod_map)++  -- Force pstate to avoid leaking the dflags0 passed to mkPackageState+  let !pstate = PackageState{+    preloadPackages     = dep_preload,+    explicitPackages    = explicit_pkgs,+    unitInfoMap            = pkg_db,+    moduleNameProvidersMap  = mod_map,+    pluginModuleNameProvidersMap = mkModuleNameProvidersMap dflags pkg_db plugin_vis_map,+    packageNameMap          = pkgname_map,+    unwireMap = Map.fromList [ (v,k) | (k,v) <- Map.toList wired_map ],+    requirementContext = req_ctx+    }+  let new_insts = fmap (map (fmap (upd_wired_in_mod wired_map))) (thisUnitIdInsts_ dflags)+  return (pstate, new_dep_preload, new_insts)++-- | Given a wired-in 'UnitId', "unwire" it into the 'UnitId'+-- that it was recorded as in the package database.+unwireUnitId :: DynFlags -> UnitId -> UnitId+unwireUnitId dflags uid@(DefiniteUnitId def_uid) =+    maybe uid DefiniteUnitId (Map.lookup def_uid (unwireMap (pkgState dflags)))+unwireUnitId _ uid = uid++-- -----------------------------------------------------------------------------+-- | Makes the mapping from module to package info++-- Slight irritation: we proceed by leafing through everything+-- in the installed package database, which makes handling indefinite+-- packages a bit bothersome.++mkModuleNameProvidersMap+  :: DynFlags+  -> UnitInfoMap+  -> VisibilityMap+  -> ModuleNameProvidersMap+mkModuleNameProvidersMap dflags pkg_db vis_map =+    -- What should we fold on?  Both situations are awkward:+    --+    --    * Folding on the visibility map means that we won't create+    --      entries for packages that aren't mentioned in vis_map+    --      (e.g., hidden packages, causing #14717)+    --+    --    * Folding on pkg_db is awkward because if we have an+    --      Backpack instantiation, we need to possibly add a+    --      package from pkg_db multiple times to the actual+    --      ModuleNameProvidersMap.  Also, we don't really want+    --      definite package instantiations to show up in the+    --      list of possibilities.+    --+    -- So what will we do instead?  We'll extend vis_map with+    -- entries for every definite (for non-Backpack) and+    -- indefinite (for Backpack) package, so that we get the+    -- hidden entries we need.+    Map.foldlWithKey extend_modmap emptyMap vis_map_extended+ where+  vis_map_extended = Map.union vis_map {- preferred -} default_vis++  default_vis = Map.fromList+                  [ (packageConfigId pkg, mempty)+                  | pkg <- eltsUDFM (unUnitInfoMap pkg_db)+                  -- Exclude specific instantiations of an indefinite+                  -- package+                  , indefinite pkg || null (instantiatedWith pkg)+                  ]++  emptyMap = Map.empty+  setOrigins m os = fmap (const os) m+  extend_modmap modmap uid+    UnitVisibility { uv_expose_all = b, uv_renamings = rns }+    = addListTo modmap theBindings+   where+    pkg = unit_lookup uid++    theBindings :: [(ModuleName, Map Module ModuleOrigin)]+    theBindings = newBindings b rns++    newBindings :: Bool+                -> [(ModuleName, ModuleName)]+                -> [(ModuleName, Map Module ModuleOrigin)]+    newBindings e rns  = es e ++ hiddens ++ map rnBinding rns++    rnBinding :: (ModuleName, ModuleName)+              -> (ModuleName, Map Module ModuleOrigin)+    rnBinding (orig, new) = (new, setOrigins origEntry fromFlag)+     where origEntry = case lookupUFM esmap orig of+            Just r -> r+            Nothing -> throwGhcException (CmdLineError (showSDoc dflags+                        (text "package flag: could not find module name" <+>+                            ppr orig <+> text "in package" <+> ppr pk)))++    es :: Bool -> [(ModuleName, Map Module ModuleOrigin)]+    es e = do+     (m, exposedReexport) <- exposed_mods+     let (pk', m', origin') =+          case exposedReexport of+           Nothing -> (pk, m, fromExposedModules e)+           Just (Module pk' m') ->+            let pkg' = unit_lookup pk'+            in (pk', m', fromReexportedModules e pkg')+     return (m, mkModMap pk' m' origin')++    esmap :: UniqFM (Map Module ModuleOrigin)+    esmap = listToUFM (es False) -- parameter here doesn't matter, orig will+                                 -- be overwritten++    hiddens = [(m, mkModMap pk m ModHidden) | m <- hidden_mods]++    pk = packageConfigId pkg+    unit_lookup uid = lookupUnit' (isIndefinite dflags) pkg_db uid+                        `orElse` pprPanic "unit_lookup" (ppr uid)++    exposed_mods = exposedModules pkg+    hidden_mods = hiddenModules pkg++-- | Make a 'ModuleNameProvidersMap' covering a set of unusable packages.+mkUnusableModuleNameProvidersMap :: UnusablePackages -> ModuleNameProvidersMap+mkUnusableModuleNameProvidersMap unusables =+    Map.foldl' extend_modmap Map.empty unusables+ where+    extend_modmap modmap (pkg, reason) = addListTo modmap bindings+      where bindings :: [(ModuleName, Map Module ModuleOrigin)]+            bindings = exposed ++ hidden++            origin = ModUnusable reason+            pkg_id = packageConfigId pkg++            exposed = map get_exposed exposed_mods+            hidden = [(m, mkModMap pkg_id m origin) | m <- hidden_mods]++            get_exposed (mod, Just mod') = (mod, Map.singleton mod' origin)+            get_exposed (mod, _)         = (mod, mkModMap pkg_id mod origin)++            exposed_mods = exposedModules pkg+            hidden_mods = hiddenModules pkg++-- | Add a list of key/value pairs to a nested map.+--+-- The outer map is processed with 'Data.Map.Strict' to prevent memory leaks+-- when reloading modules in GHCi (see #4029). This ensures that each+-- value is forced before installing into the map.+addListTo :: (Monoid a, Ord k1, Ord k2)+          => Map k1 (Map k2 a)+          -> [(k1, Map k2 a)]+          -> Map k1 (Map k2 a)+addListTo = foldl' merge+  where merge m (k, v) = MapStrict.insertWith (Map.unionWith mappend) k v m++-- | Create a singleton module mapping+mkModMap :: UnitId -> ModuleName -> ModuleOrigin -> Map Module ModuleOrigin+mkModMap pkg mod = Map.singleton (mkModule pkg mod)++-- -----------------------------------------------------------------------------+-- Extracting information from the packages in scope++-- Many of these functions take a list of packages: in those cases,+-- the list is expected to contain the "dependent packages",+-- i.e. those packages that were found to be depended on by the+-- current module/program.  These can be auto or non-auto packages, it+-- doesn't really matter.  The list is always combined with the list+-- of preload (command-line) packages to determine which packages to+-- use.++-- | Find all the include directories in these and the preload packages+getPackageIncludePath :: DynFlags -> [PreloadUnitId] -> IO [String]+getPackageIncludePath dflags pkgs =+  collectIncludeDirs `fmap` getPreloadPackagesAnd dflags pkgs++collectIncludeDirs :: [UnitInfo] -> [FilePath]+collectIncludeDirs ps = ordNub (filter notNull (concatMap includeDirs ps))++-- | Find all the library paths in these and the preload packages+getPackageLibraryPath :: DynFlags -> [PreloadUnitId] -> IO [String]+getPackageLibraryPath dflags pkgs =+  collectLibraryPaths dflags `fmap` getPreloadPackagesAnd dflags pkgs++collectLibraryPaths :: DynFlags -> [UnitInfo] -> [FilePath]+collectLibraryPaths dflags = ordNub . filter notNull+                           . concatMap (libraryDirsForWay dflags)++-- | Find all the link options in these and the preload packages,+-- returning (package hs lib options, extra library options, other flags)+getPackageLinkOpts :: DynFlags -> [PreloadUnitId] -> IO ([String], [String], [String])+getPackageLinkOpts dflags pkgs =+  collectLinkOpts dflags `fmap` getPreloadPackagesAnd dflags pkgs++collectLinkOpts :: DynFlags -> [UnitInfo] -> ([String], [String], [String])+collectLinkOpts dflags ps =+    (+        concatMap (map ("-l" ++) . packageHsLibs dflags) ps,+        concatMap (map ("-l" ++) . extraLibraries) ps,+        concatMap ldOptions ps+    )+collectArchives :: DynFlags -> UnitInfo -> IO [FilePath]+collectArchives dflags pc =+  filterM doesFileExist [ searchPath </> ("lib" ++ lib ++ ".a")+                        | searchPath <- searchPaths+                        , lib <- libs ]+  where searchPaths = ordNub . filter notNull . libraryDirsForWay dflags $ pc+        libs        = packageHsLibs dflags pc ++ extraLibraries pc++getLibs :: DynFlags -> [PreloadUnitId] -> IO [(String,String)]+getLibs dflags pkgs = do+  ps <- getPreloadPackagesAnd dflags pkgs+  fmap concat . forM ps $ \p -> do+    let candidates = [ (l </> f, f) | l <- collectLibraryPaths dflags [p]+                                    , f <- (\n -> "lib" ++ n ++ ".a") <$> packageHsLibs dflags p ]+    filterM (doesFileExist . fst) candidates++packageHsLibs :: DynFlags -> UnitInfo -> [String]+packageHsLibs dflags p = map (mkDynName . addSuffix) (hsLibraries p)+  where+        ways0 = ways dflags++        ways1 = filter (/= WayDyn) ways0+        -- the name of a shared library is libHSfoo-ghc<version>.so+        -- we leave out the _dyn, because it is superfluous++        -- debug and profiled RTSs include support for -eventlog+        ways2 | WayDebug `elem` ways1 || WayProf `elem` ways1+              = filter (/= WayEventLog) ways1+              | otherwise+              = ways1++        tag     = mkBuildTag (filter (not . wayRTSOnly) ways2)+        rts_tag = mkBuildTag ways2++        mkDynName x+         | WayDyn `notElem` ways dflags = x+         | "HS" `isPrefixOf` x          =+              x ++ '-':programName dflags ++ projectVersion dflags+           -- For non-Haskell libraries, we use the name "Cfoo". The .a+           -- file is libCfoo.a, and the .so is libfoo.so. That way the+           -- linker knows what we mean for the vanilla (-lCfoo) and dyn+           -- (-lfoo) ways. We therefore need to strip the 'C' off here.+         | Just x' <- stripPrefix "C" x = x'+         | 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 = ""+                    | otherwise = '_':t++-- | Either the 'libraryDirs' or 'libraryDynDirs' as appropriate for the way.+libraryDirsForWay :: DynFlags -> UnitInfo -> [String]+libraryDirsForWay dflags+  | WayDyn `elem` ways dflags = libraryDynDirs+  | otherwise                 = libraryDirs++-- | Find all the C-compiler options in these and the preload packages+getPackageExtraCcOpts :: DynFlags -> [PreloadUnitId] -> IO [String]+getPackageExtraCcOpts dflags pkgs = do+  ps <- getPreloadPackagesAnd dflags pkgs+  return (concatMap ccOptions ps)++-- | Find all the package framework paths in these and the preload packages+getPackageFrameworkPath  :: DynFlags -> [PreloadUnitId] -> IO [String]+getPackageFrameworkPath dflags pkgs = do+  ps <- getPreloadPackagesAnd dflags pkgs+  return (ordNub (filter notNull (concatMap frameworkDirs ps)))++-- | Find all the package frameworks in these and the preload packages+getPackageFrameworks  :: DynFlags -> [PreloadUnitId] -> IO [String]+getPackageFrameworks dflags pkgs = do+  ps <- getPreloadPackagesAnd dflags pkgs+  return (concatMap frameworks ps)++-- -----------------------------------------------------------------------------+-- Package Utils++-- | Takes a 'ModuleName', and if the module is in any package returns+-- list of modules which take that name.+lookupModuleInAllPackages :: DynFlags+                          -> ModuleName+                          -> [(Module, UnitInfo)]+lookupModuleInAllPackages dflags m+  = case lookupModuleWithSuggestions dflags m Nothing of+      LookupFound a b -> [(a,b)]+      LookupMultiple rs -> map f rs+        where f (m,_) = (m, expectJust "lookupModule" (lookupUnit dflags+                                                         (moduleUnitId m)))+      _ -> []++-- | The result of performing a lookup+data LookupResult =+    -- | Found the module uniquely, nothing else to do+    LookupFound Module UnitInfo+    -- | Multiple modules with the same name in scope+  | LookupMultiple [(Module, ModuleOrigin)]+    -- | No modules found, but there were some hidden ones with+    -- an exact name match.  First is due to package hidden, second+    -- is due to module being hidden+  | LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]+    -- | No modules found, but there were some unusable ones with+    -- an exact name match+  | LookupUnusable [(Module, ModuleOrigin)]+    -- | Nothing found, here are some suggested different names+  | LookupNotFound [ModuleSuggestion] -- suggestions++data ModuleSuggestion = SuggestVisible ModuleName Module ModuleOrigin+                      | SuggestHidden ModuleName Module ModuleOrigin++lookupModuleWithSuggestions :: DynFlags+                            -> ModuleName+                            -> Maybe FastString+                            -> LookupResult+lookupModuleWithSuggestions dflags+  = lookupModuleWithSuggestions' dflags+        (moduleNameProvidersMap (pkgState dflags))++lookupPluginModuleWithSuggestions :: DynFlags+                                  -> ModuleName+                                  -> Maybe FastString+                                  -> LookupResult+lookupPluginModuleWithSuggestions dflags+  = lookupModuleWithSuggestions' dflags+        (pluginModuleNameProvidersMap (pkgState dflags))++lookupModuleWithSuggestions' :: DynFlags+                            -> ModuleNameProvidersMap+                            -> ModuleName+                            -> Maybe FastString+                            -> LookupResult+lookupModuleWithSuggestions' dflags mod_map m mb_pn+  = case Map.lookup m mod_map of+        Nothing -> LookupNotFound suggestions+        Just xs ->+          case foldl' classify ([],[],[], []) (Map.toList xs) of+            ([], [], [], []) -> LookupNotFound suggestions+            (_, _, _, [(m, _)])             -> LookupFound m (mod_unit m)+            (_, _, _, exposed@(_:_))        -> LookupMultiple exposed+            ([], [], unusable@(_:_), [])    -> LookupUnusable unusable+            (hidden_pkg, hidden_mod, _, []) ->+              LookupHidden hidden_pkg hidden_mod+  where+    classify (hidden_pkg, hidden_mod, unusable, exposed) (m, origin0) =+      let origin = filterOrigin mb_pn (mod_unit m) origin0+          x = (m, origin)+      in case origin of+          ModHidden+            -> (hidden_pkg, x:hidden_mod, unusable, exposed)+          ModUnusable _+            -> (hidden_pkg, hidden_mod, x:unusable, exposed)+          _ | originEmpty origin+            -> (hidden_pkg,   hidden_mod, unusable, exposed)+            | originVisible origin+            -> (hidden_pkg, hidden_mod, unusable, x:exposed)+            | otherwise+            -> (x:hidden_pkg, hidden_mod, unusable, exposed)++    unit_lookup p = lookupUnit dflags p `orElse` pprPanic "lookupModuleWithSuggestions" (ppr p <+> ppr m)+    mod_unit = unit_lookup . moduleUnitId++    -- Filters out origins which are not associated with the given package+    -- qualifier.  No-op if there is no package qualifier.  Test if this+    -- excluded all origins with 'originEmpty'.+    filterOrigin :: Maybe FastString+                 -> UnitInfo+                 -> ModuleOrigin+                 -> ModuleOrigin+    filterOrigin Nothing _ o = o+    filterOrigin (Just pn) pkg o =+      case o of+          ModHidden -> if go pkg then ModHidden else mempty+          (ModUnusable _) -> if go pkg then o else mempty+          ModOrigin { fromOrigPackage = e, fromExposedReexport = res,+                      fromHiddenReexport = rhs }+            -> ModOrigin {+                  fromOrigPackage = if go pkg then e else Nothing+                , fromExposedReexport = filter go res+                , fromHiddenReexport = filter go rhs+                , fromPackageFlag = False -- always excluded+                }+      where go pkg = pn == fsPackageName pkg++    suggestions+      | gopt Opt_HelpfulErrors dflags =+           fuzzyLookup (moduleNameString m) all_mods+      | otherwise = []++    all_mods :: [(String, ModuleSuggestion)]     -- All modules+    all_mods = sortBy (comparing fst) $+        [ (moduleNameString m, suggestion)+        | (m, e) <- Map.toList (moduleNameProvidersMap (pkgState dflags))+        , suggestion <- map (getSuggestion m) (Map.toList e)+        ]+    getSuggestion name (mod, origin) =+        (if originVisible origin then SuggestVisible else SuggestHidden)+            name mod origin++listVisibleModuleNames :: DynFlags -> [ModuleName]+listVisibleModuleNames dflags =+    map fst (filter visible (Map.toList (moduleNameProvidersMap (pkgState dflags))))+  where visible (_, ms) = any originVisible (Map.elems ms)++-- | Find all the 'UnitInfo' in both the preload packages from 'DynFlags' and corresponding to the list of+-- 'UnitInfo's+getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [UnitInfo]+getPreloadPackagesAnd dflags pkgids0 =+  let+      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 = unitInfoMap state+      preload = preloadPackages state+      pairs = zip pkgids (repeat Nothing)+  in do+  all_pkgs <- throwErr dflags (foldM (add_package dflags pkg_map) preload pairs)+  return (map (getInstalledPackageDetails dflags) all_pkgs)++-- Takes a list of packages, and returns the list with dependencies included,+-- in reverse dependency order (a package appears before those it depends on).+closeDeps :: DynFlags+          -> UnitInfoMap+          -> [(InstalledUnitId, Maybe InstalledUnitId)]+          -> IO [InstalledUnitId]+closeDeps dflags pkg_map ps+    = throwErr dflags (closeDepsErr dflags pkg_map ps)++throwErr :: DynFlags -> MaybeErr MsgDoc a -> IO a+throwErr dflags m+              = case m of+                Failed e    -> throwGhcExceptionIO (CmdLineError (showSDoc dflags e))+                Succeeded r -> return r++closeDepsErr :: DynFlags+             -> UnitInfoMap+             -> [(InstalledUnitId,Maybe InstalledUnitId)]+             -> MaybeErr MsgDoc [InstalledUnitId]+closeDepsErr dflags pkg_map ps = foldM (add_package dflags pkg_map) [] ps++-- internal helper+add_package :: DynFlags+            -> UnitInfoMap+            -> [PreloadUnitId]+            -> (PreloadUnitId,Maybe PreloadUnitId)+            -> MaybeErr MsgDoc [PreloadUnitId]+add_package dflags pkg_db ps (p, mb_parent)+  | p `elem` ps = return ps     -- Check if we've already added this package+  | otherwise =+      case lookupInstalledPackage' pkg_db p of+        Nothing -> Failed (missingPackageMsg p <>+                           missingDependencyMsg mb_parent)+        Just pkg -> do+           -- Add the package's dependents also+           ps' <- foldM add_unit_key ps (depends pkg)+           return (p : ps')+          where+            add_unit_key ps key+              = add_package dflags pkg_db ps (key, Just p)++missingPackageMsg :: Outputable pkgid => pkgid -> SDoc+missingPackageMsg p = text "unknown package:" <+> ppr p++missingDependencyMsg :: Maybe InstalledUnitId -> SDoc+missingDependencyMsg Nothing = Outputable.empty+missingDependencyMsg (Just parent)+  = space <> parens (text "dependency of" <+> ftext (installedUnitIdFS parent))++-- -----------------------------------------------------------------------------++componentIdString :: DynFlags -> ComponentId -> Maybe String+componentIdString dflags cid = do+    conf <- lookupInstalledPackage dflags (componentIdToInstalledUnitId cid)+    return $+        case sourceLibName conf of+            Nothing -> sourcePackageIdString conf+            Just (PackageName libname) ->+                packageNameString conf+                    ++ "-" ++ showVersion (packageVersion conf)+                    ++ ":" ++ unpackFS libname++displayInstalledUnitId :: DynFlags -> InstalledUnitId -> Maybe String+displayInstalledUnitId dflags uid =+    fmap sourcePackageIdString (lookupInstalledPackage dflags uid)++-- | Will the 'Name' come from a dynamically linked library?+isDllName :: DynFlags -> Module -> Name -> Bool+-- Despite the "dll", I think this function just means that+-- the symbol comes from another dynamically-linked package,+-- and applies on all platforms, not just Windows+isDllName dflags this_mod name+  | not (gopt Opt_ExternalDynamicRefs dflags) = False+  | Just mod <- nameModule_maybe name+    -- Issue #8696 - when GHC is dynamically linked, it will attempt+    -- to load the dynamic dependencies of object files at compile+    -- time for things like QuasiQuotes or+    -- TemplateHaskell. Unfortunately, this interacts badly with+    -- intra-package linking, because we don't generate indirect+    -- (dynamic) symbols for intra-package calls. This means that if a+    -- module with an intra-package call is loaded without its+    -- dependencies, then GHC fails to link. This is the cause of #+    --+    -- In the mean time, always force dynamic indirections to be+    -- generated: when the module name isn't the module being+    -- compiled, references are dynamic.+    = 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. referring 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++-- -----------------------------------------------------------------------------+-- Displaying packages++-- | Show (very verbose) package info+pprPackages :: DynFlags -> SDoc+pprPackages = pprPackagesWith pprUnitInfo++pprPackagesWith :: (UnitInfo -> SDoc) -> DynFlags -> SDoc+pprPackagesWith pprIPI dflags =+    vcat (intersperse (text "---") (map pprIPI (listUnitInfoMap dflags)))++-- | Show simplified package info.+--+-- The idea is to only print package id, and any information that might+-- be different from the package databases (exposure, trust)+pprPackagesSimple :: DynFlags -> SDoc+pprPackagesSimple = pprPackagesWith pprIPI+    where pprIPI ipi = let i = installedUnitIdFS (unitId ipi)+                           e = if exposed ipi then text "E" else text " "+                           t = if trusted ipi then text "T" else text " "+                       in e <> t <> text "  " <> ftext i++-- | Show the mapping of modules to where they come from.+pprModuleMap :: ModuleNameProvidersMap -> SDoc+pprModuleMap mod_map =+  vcat (map pprLine (Map.toList mod_map))+    where+      pprLine (m,e) = ppr m $$ nest 50 (vcat (map (pprEntry m) (Map.toList e)))+      pprEntry :: Outputable a => ModuleName -> (Module, a) -> SDoc+      pprEntry m (m',o)+        | m == moduleName m' = ppr (moduleUnitId m') <+> parens (ppr o)+        | otherwise = ppr m' <+> parens (ppr o)++fsPackageName :: UnitInfo -> FastString+fsPackageName = mkFastString . packageNameString++-- | Given a fully instantiated 'UnitId', improve it into a+-- 'InstalledUnitId' if we can find it in the package database.+improveUnitId :: UnitInfoMap -> UnitId -> UnitId+improveUnitId _ uid@(DefiniteUnitId _) = uid -- short circuit+improveUnitId pkg_map uid =+    -- Do NOT lookup indefinite ones, they won't be useful!+    case lookupUnit' False pkg_map uid of+        Nothing  -> uid+        Just pkg ->+            -- Do NOT improve if the indefinite unit id is not+            -- part of the closure unique set.  See+            -- Note [UnitId to InstalledUnitId improvement]+            if installedUnitInfoId pkg `elementOfUniqSet` preloadClosure pkg_map+                then packageConfigId pkg+                else uid++-- | Retrieve the 'UnitInfoMap' from 'DynFlags'; used+-- in the @hs-boot@ loop-breaker.+getUnitInfoMap :: DynFlags -> UnitInfoMap+getUnitInfoMap = unitInfoMap . pkgState

+ compiler/GHC/Driver/Packages.hs-boot view

@@ -0,0 +1,12 @@+module GHC.Driver.Packages where+import GhcPrelude+import {-# SOURCE #-} GHC.Driver.Session (DynFlags)+import {-# SOURCE #-} Module(ComponentId, UnitId, InstalledUnitId)+data PackageState+data UnitInfoMap+data PackageDatabase+emptyPackageState :: PackageState+componentIdString :: DynFlags -> ComponentId -> Maybe String+displayInstalledUnitId :: DynFlags -> InstalledUnitId -> Maybe String+improveUnitId :: UnitInfoMap -> UnitId -> UnitId+getUnitInfoMap :: DynFlags -> UnitInfoMap

+ compiler/GHC/Driver/Phases.hs view

@@ -0,0 +1,370 @@+{-# LANGUAGE CPP #-}++-----------------------------------------------------------------------------+--+-- GHC Driver+--+-- (c) The University of Glasgow 2002+--+-----------------------------------------------------------------------------++module GHC.Driver.Phases (+   HscSource(..), isHsBootOrSig, isHsigFile, hscSourceString,+   Phase(..),+   happensBefore, eqPhase, anyHsc, isStopLn,+   startPhase,+   phaseInputExt,++   isHaskellishSuffix,+   isHaskellSrcSuffix,+   isBackpackishSuffix,+   isObjectSuffix,+   isCishSuffix,+   isDynLibSuffix,+   isHaskellUserSrcSuffix,+   isHaskellSigSuffix,+   isSourceSuffix,++   isHaskellishTarget,++   isHaskellishFilename,+   isHaskellSrcFilename,+   isHaskellSigFilename,+   isObjectFilename,+   isCishFilename,+   isDynLibFilename,+   isHaskellUserSrcFilename,+   isSourceFilename+ ) where++#include "HsVersions.h"++import GhcPrelude++import {-# SOURCE #-} GHC.Driver.Session+import Outputable+import GHC.Platform+import System.FilePath+import Binary+import Util++-----------------------------------------------------------------------------+-- Phases++{-+   Phase of the           | Suffix saying | Flag saying   | (suffix of)+   compilation system     | ``start here''| ``stop after''| output file++   literate pre-processor | .lhs          | -             | -+   C pre-processor (opt.) | -             | -E            | -+   Haskell compiler       | .hs           | -C, -S        | .hc, .s+   C compiler (opt.)      | .hc or .c     | -S            | .s+   assembler              | .s  or .S     | -c            | .o+   linker                 | other         | -             | a.out+-}++-- Note [HscSource types]+-- ~~~~~~~~~~~~~~~~~~~~~~+-- There are three types of source file for Haskell code:+--+--      * HsSrcFile is an ordinary hs file which contains code,+--+--      * HsBootFile is an hs-boot file, which is used to break+--        recursive module imports (there will always be an+--        HsSrcFile associated with it), and+--+--      * HsigFile is an hsig file, which contains only type+--        signatures and is used to specify signatures for+--        modules.+--+-- Syntactically, hs-boot files and hsig files are quite similar: they+-- only include type signatures and must be associated with an+-- actual HsSrcFile.  isHsBootOrSig allows us to abstract over code+-- which is indifferent to which.  However, there are some important+-- differences, mostly owing to the fact that hsigs are proper+-- modules (you `import Sig` directly) whereas HsBootFiles are+-- temporary placeholders (you `import {-# SOURCE #-} Mod).+-- When we finish compiling the true implementation of an hs-boot,+-- we replace the HomeModInfo with the real HsSrcFile.  An HsigFile, on the+-- other hand, is never replaced (in particular, we *cannot* use the+-- HomeModInfo of the original HsSrcFile backing the signature, since it+-- will export too many symbols.)+--+-- Additionally, while HsSrcFile is the only Haskell file+-- which has *code*, we do generate .o files for HsigFile, because+-- this is how the recompilation checker figures out if a file+-- needs to be recompiled.  These are fake object files which+-- should NOT be linked against.++data HscSource+   = HsSrcFile | HsBootFile | HsigFile+     deriving( Eq, Ord, Show )+        -- Ord needed for the finite maps we build in CompManager++instance Binary HscSource where+    put_ bh HsSrcFile = putByte bh 0+    put_ bh HsBootFile = putByte bh 1+    put_ bh HsigFile = putByte bh 2+    get bh = do+        h <- getByte bh+        case h of+            0 -> return HsSrcFile+            1 -> return HsBootFile+            _ -> return HsigFile++hscSourceString :: HscSource -> String+hscSourceString HsSrcFile   = ""+hscSourceString HsBootFile  = "[boot]"+hscSourceString HsigFile    = "[sig]"++-- See Note [isHsBootOrSig]+isHsBootOrSig :: HscSource -> Bool+isHsBootOrSig HsBootFile = True+isHsBootOrSig HsigFile   = True+isHsBootOrSig _          = False++isHsigFile :: HscSource -> Bool+isHsigFile HsigFile = True+isHsigFile _        = False++data Phase+        = Unlit HscSource+        | Cpp   HscSource+        | HsPp  HscSource+        | Hsc   HscSource+        | Ccxx          -- Compile C+++        | Cc            -- Compile C+        | Cobjc         -- Compile Objective-C+        | Cobjcxx       -- Compile Objective-C+++        | HCc           -- Haskellised C (as opposed to vanilla C) compilation+        | As Bool       -- Assembler for regular assembly files (Bool: with-cpp)+        | LlvmOpt       -- Run LLVM opt tool over llvm assembly+        | LlvmLlc       -- LLVM bitcode to native assembly+        | LlvmMangle    -- Fix up TNTC by processing assembly produced by LLVM+        | CmmCpp        -- pre-process Cmm source+        | Cmm           -- parse & compile Cmm code+        | MergeForeign  -- merge in the foreign object files++        -- The final phase is a pseudo-phase that tells the pipeline to stop.+        -- There is no runPhase case for it.+        | StopLn        -- Stop, but linking will follow, so generate .o file+  deriving (Eq, Show)++instance Outputable Phase where+    ppr p = text (show p)++anyHsc :: Phase+anyHsc = Hsc (panic "anyHsc")++isStopLn :: Phase -> Bool+isStopLn StopLn = True+isStopLn _      = False++eqPhase :: Phase -> Phase -> Bool+-- Equality of constructors, ignoring the HscSource field+-- NB: the HscSource field can be 'bot'; see anyHsc above+eqPhase (Unlit _)   (Unlit _)  = True+eqPhase (Cpp   _)   (Cpp   _)  = True+eqPhase (HsPp  _)   (HsPp  _)  = True+eqPhase (Hsc   _)   (Hsc   _)  = True+eqPhase Cc          Cc         = True+eqPhase Cobjc       Cobjc      = True+eqPhase HCc         HCc        = True+eqPhase (As x)      (As y)     = x == y+eqPhase LlvmOpt     LlvmOpt    = True+eqPhase LlvmLlc     LlvmLlc    = True+eqPhase LlvmMangle  LlvmMangle = True+eqPhase CmmCpp      CmmCpp     = True+eqPhase Cmm         Cmm        = True+eqPhase MergeForeign MergeForeign  = True+eqPhase StopLn      StopLn     = True+eqPhase Ccxx        Ccxx       = True+eqPhase Cobjcxx     Cobjcxx    = True+eqPhase _           _          = False++{- Note [Partial ordering on phases]++We want to know which phases will occur before which others. This is used for+sanity checking, to ensure that the pipeline will stop at some point (see+GHC.Driver.Pipeline.runPipeline).++A < B iff A occurs before B in a normal compilation pipeline.++There is explicitly not a total ordering on phases, because in registerised+builds, the phase `HsC` doesn't happen before nor after any other phase.++Although we check that a normal user doesn't set the stop_phase to HsC through+use of -C with registerised builds (in Main.checkOptions), it is still+possible for a ghc-api user to do so. So be careful when using the function+happensBefore, and don't think that `not (a <= b)` implies `b < a`.+-}+happensBefore :: DynFlags -> Phase -> Phase -> Bool+happensBefore dflags p1 p2 = p1 `happensBefore'` p2+    where StopLn `happensBefore'` _ = False+          x      `happensBefore'` y = after_x `eqPhase` y+                                   || after_x `happensBefore'` y+              where after_x = nextPhase dflags x++nextPhase :: DynFlags -> Phase -> Phase+nextPhase dflags p+    -- A conservative approximation to the next phase, used in happensBefore+    = case p of+      Unlit sf   -> Cpp  sf+      Cpp   sf   -> HsPp sf+      HsPp  sf   -> Hsc  sf+      Hsc   _    -> maybeHCc+      LlvmOpt    -> LlvmLlc+      LlvmLlc    -> LlvmMangle+      LlvmMangle -> As False+      As _       -> MergeForeign+      Ccxx       -> As False+      Cc         -> As False+      Cobjc      -> As False+      Cobjcxx    -> As False+      CmmCpp     -> Cmm+      Cmm        -> maybeHCc+      HCc        -> As False+      MergeForeign -> StopLn+      StopLn     -> panic "nextPhase: nothing after StopLn"+    where maybeHCc = if platformUnregisterised (targetPlatform dflags)+                     then HCc+                     else As False++-- the first compilation phase for a given file is determined+-- by its suffix.+startPhase :: String -> Phase+startPhase "lhs"      = Unlit HsSrcFile+startPhase "lhs-boot" = Unlit HsBootFile+startPhase "lhsig"    = Unlit HsigFile+startPhase "hs"       = Cpp   HsSrcFile+startPhase "hs-boot"  = Cpp   HsBootFile+startPhase "hsig"     = Cpp   HsigFile+startPhase "hscpp"    = HsPp  HsSrcFile+startPhase "hspp"     = Hsc   HsSrcFile+startPhase "hc"       = HCc+startPhase "c"        = Cc+startPhase "cpp"      = Ccxx+startPhase "C"        = Cc+startPhase "m"        = Cobjc+startPhase "M"        = Cobjcxx+startPhase "mm"       = Cobjcxx+startPhase "cc"       = Ccxx+startPhase "cxx"      = Ccxx+startPhase "s"        = As False+startPhase "S"        = As True+startPhase "ll"       = LlvmOpt+startPhase "bc"       = LlvmLlc+startPhase "lm_s"     = LlvmMangle+startPhase "o"        = StopLn+startPhase "cmm"      = CmmCpp+startPhase "cmmcpp"   = Cmm+startPhase _          = StopLn     -- all unknown file types++-- This is used to determine the extension for the output from the+-- current phase (if it generates a new file).  The extension depends+-- on the next phase in the pipeline.+phaseInputExt :: Phase -> String+phaseInputExt (Unlit HsSrcFile)   = "lhs"+phaseInputExt (Unlit HsBootFile)  = "lhs-boot"+phaseInputExt (Unlit HsigFile)    = "lhsig"+phaseInputExt (Cpp   _)           = "lpp"       -- intermediate only+phaseInputExt (HsPp  _)           = "hscpp"     -- intermediate only+phaseInputExt (Hsc   _)           = "hspp"      -- intermediate only+        -- NB: as things stand, phaseInputExt (Hsc x) must not evaluate x+        --     because runPipeline uses the StopBefore phase to pick the+        --     output filename.  That could be fixed, but watch out.+phaseInputExt HCc                 = "hc"+phaseInputExt Ccxx                = "cpp"+phaseInputExt Cobjc               = "m"+phaseInputExt Cobjcxx             = "mm"+phaseInputExt Cc                  = "c"+phaseInputExt (As True)           = "S"+phaseInputExt (As False)          = "s"+phaseInputExt LlvmOpt             = "ll"+phaseInputExt LlvmLlc             = "bc"+phaseInputExt LlvmMangle          = "lm_s"+phaseInputExt CmmCpp              = "cmmcpp"+phaseInputExt Cmm                 = "cmm"+phaseInputExt MergeForeign        = "o"+phaseInputExt StopLn              = "o"++haskellish_src_suffixes, backpackish_suffixes, haskellish_suffixes, cish_suffixes,+    haskellish_user_src_suffixes, haskellish_sig_suffixes+ :: [String]+-- When a file with an extension in the haskellish_src_suffixes group is+-- loaded in --make mode, its imports will be loaded too.+haskellish_src_suffixes      = haskellish_user_src_suffixes +++                               [ "hspp", "hscpp" ]+haskellish_suffixes          = haskellish_src_suffixes +++                               [ "hc", "cmm", "cmmcpp" ]+cish_suffixes                = [ "c", "cpp", "C", "cc", "cxx", "s", "S", "ll", "bc", "lm_s", "m", "M", "mm" ]++-- Will not be deleted as temp files:+haskellish_user_src_suffixes =+  haskellish_sig_suffixes ++ [ "hs", "lhs", "hs-boot", "lhs-boot" ]+haskellish_sig_suffixes      = [ "hsig", "lhsig" ]+backpackish_suffixes         = [ "bkp" ]++objish_suffixes :: Platform -> [String]+-- Use the appropriate suffix for the system on which+-- the GHC-compiled code will run+objish_suffixes platform = case platformOS platform of+  OSMinGW32 -> [ "o", "O", "obj", "OBJ" ]+  _         -> [ "o" ]++dynlib_suffixes :: Platform -> [String]+dynlib_suffixes platform = case platformOS platform of+  OSMinGW32 -> ["dll", "DLL"]+  OSDarwin  -> ["dylib", "so"]+  _         -> ["so"]++isHaskellishSuffix, isBackpackishSuffix, isHaskellSrcSuffix, isCishSuffix,+    isHaskellUserSrcSuffix, isHaskellSigSuffix+ :: String -> Bool+isHaskellishSuffix     s = s `elem` haskellish_suffixes+isBackpackishSuffix    s = s `elem` backpackish_suffixes+isHaskellSigSuffix     s = s `elem` haskellish_sig_suffixes+isHaskellSrcSuffix     s = s `elem` haskellish_src_suffixes+isCishSuffix           s = s `elem` cish_suffixes+isHaskellUserSrcSuffix s = s `elem` haskellish_user_src_suffixes++isObjectSuffix, isDynLibSuffix :: Platform -> String -> Bool+isObjectSuffix platform s = s `elem` objish_suffixes platform+isDynLibSuffix platform s = s `elem` dynlib_suffixes platform++isSourceSuffix :: String -> Bool+isSourceSuffix suff  = isHaskellishSuffix suff+                    || isCishSuffix suff+                    || isBackpackishSuffix suff++-- | When we are given files (modified by -x arguments) we need+-- to determine if they are Haskellish or not to figure out+-- how we should try to compile it.  The rules are:+--+--      1. If no -x flag was specified, we check to see if+--         the file looks like a module name, has no extension,+--         or has a Haskell source extension.+--+--      2. If an -x flag was specified, we just make sure the+--         specified suffix is a Haskell one.+isHaskellishTarget :: (String, Maybe Phase) -> Bool+isHaskellishTarget (f,Nothing) =+  looksLikeModuleName f || isHaskellSrcFilename f || not (hasExtension f)+isHaskellishTarget (_,Just phase) =+  phase `notElem` [ As True, As False, Cc, Cobjc, Cobjcxx, CmmCpp, Cmm+                  , StopLn]++isHaskellishFilename, isHaskellSrcFilename, isCishFilename,+    isHaskellUserSrcFilename, isSourceFilename, isHaskellSigFilename+ :: FilePath -> Bool+-- takeExtension return .foo, so we drop 1 to get rid of the .+isHaskellishFilename     f = isHaskellishSuffix     (drop 1 $ takeExtension f)+isHaskellSrcFilename     f = isHaskellSrcSuffix     (drop 1 $ takeExtension f)+isCishFilename           f = isCishSuffix           (drop 1 $ takeExtension f)+isHaskellUserSrcFilename f = isHaskellUserSrcSuffix (drop 1 $ takeExtension f)+isSourceFilename         f = isSourceSuffix         (drop 1 $ takeExtension f)+isHaskellSigFilename     f = isHaskellSigSuffix     (drop 1 $ takeExtension f)++isObjectFilename, isDynLibFilename :: Platform -> FilePath -> Bool+isObjectFilename platform f = isObjectSuffix platform (drop 1 $ takeExtension f)+isDynLibFilename platform f = isDynLibSuffix platform (drop 1 $ takeExtension f)

+ compiler/GHC/Driver/Pipeline/Monad.hs view

@@ -0,0 +1,122 @@+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE NamedFieldPuns #-}+-- | The CompPipeline monad and associated ops+--+-- Defined in separate module so that it can safely be imported from Hooks+module GHC.Driver.Pipeline.Monad (+    CompPipeline(..), evalP+  , PhasePlus(..)+  , PipeEnv(..), PipeState(..), PipelineOutput(..)+  , getPipeEnv, getPipeState, setDynFlags, setModLocation, setForeignOs, setIface+  , pipeStateDynFlags, pipeStateModIface+  ) where++import GhcPrelude++import MonadUtils+import Outputable+import GHC.Driver.Session+import GHC.Driver.Phases+import GHC.Driver.Types+import Module+import FileCleanup (TempFileLifetime)++import Control.Monad++newtype CompPipeline a = P { unP :: PipeEnv -> PipeState -> IO (PipeState, a) }+    deriving (Functor)++evalP :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)+evalP (P f) env st = f env st++instance Applicative CompPipeline where+    pure a = P $ \_env state -> return (state, a)+    (<*>) = ap++instance Monad CompPipeline where+  P m >>= k = P $ \env state -> do (state',a) <- m env state+                                   unP (k a) env state'++instance MonadIO CompPipeline where+    liftIO m = P $ \_env state -> do a <- m; return (state, a)++data PhasePlus = RealPhase Phase+               | HscOut HscSource ModuleName HscStatus++instance Outputable PhasePlus where+    ppr (RealPhase p) = ppr p+    ppr (HscOut {}) = text "HscOut"++-- -----------------------------------------------------------------------------+-- The pipeline uses a monad to carry around various bits of information++-- PipeEnv: invariant information passed down+data PipeEnv = PipeEnv {+       stop_phase   :: Phase,       -- ^ Stop just before this phase+       src_filename :: String,      -- ^ basename of original input source+       src_basename :: String,      -- ^ basename of original input source+       src_suffix   :: String,      -- ^ its extension+       output_spec  :: PipelineOutput -- ^ says where to put the pipeline output+  }++-- PipeState: information that might change during a pipeline run+data PipeState = PipeState {+       hsc_env   :: HscEnv,+          -- ^ only the DynFlags change in the HscEnv.  The DynFlags change+          -- at various points, for example when we read the OPTIONS_GHC+          -- pragmas in the Cpp phase.+       maybe_loc :: Maybe ModLocation,+          -- ^ the ModLocation.  This is discovered during compilation,+          -- in the Hsc phase where we read the module header.+       foreign_os :: [FilePath],+         -- ^ additional object files resulting from compiling foreign+         -- code. They come from two sources: foreign stubs, and+         -- add{C,Cxx,Objc,Objcxx}File from template haskell+       iface :: Maybe (ModIface, ModDetails)+         -- ^ Interface generated by HscOut phase. Only available after the+         -- phase runs.+  }++pipeStateDynFlags :: PipeState -> DynFlags+pipeStateDynFlags = hsc_dflags . hsc_env++pipeStateModIface :: PipeState -> Maybe (ModIface, ModDetails)+pipeStateModIface = iface++data PipelineOutput+  = Temporary TempFileLifetime+        -- ^ Output should be to a temporary file: we're going to+        -- run more compilation steps on this output later.+  | Persistent+        -- ^ We want a persistent file, i.e. a file in the current directory+        -- derived from the input filename, but with the appropriate extension.+        -- eg. in "ghc -c Foo.hs" the output goes into ./Foo.o.+  | SpecificFile+        -- ^ The output must go into the specific outputFile in DynFlags.+        -- We don't store the filename in the constructor as it changes+        -- when doing -dynamic-too.+    deriving Show++getPipeEnv :: CompPipeline PipeEnv+getPipeEnv = P $ \env state -> return (state, env)++getPipeState :: CompPipeline PipeState+getPipeState = P $ \_env state -> return (state, state)++instance HasDynFlags CompPipeline where+    getDynFlags = P $ \_env state -> return (state, hsc_dflags (hsc_env state))++setDynFlags :: DynFlags -> CompPipeline ()+setDynFlags dflags = P $ \_env state ->+  return (state{hsc_env= (hsc_env state){ hsc_dflags = dflags }}, ())++setModLocation :: ModLocation -> CompPipeline ()+setModLocation loc = P $ \_env state ->+  return (state{ maybe_loc = Just loc }, ())++setForeignOs :: [FilePath] -> CompPipeline ()+setForeignOs os = P $ \_env state ->+  return (state{ foreign_os = os }, ())++setIface :: ModIface -> ModDetails -> CompPipeline ()+setIface iface details = P $ \_env state -> return (state{ iface = Just (iface, details) }, ())

+ compiler/GHC/Driver/Plugins.hs view

@@ -0,0 +1,264 @@+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE CPP #-}++-- | Definitions for writing /plugins/ for GHC. Plugins can hook into+-- several areas of the compiler. See the 'Plugin' type. These plugins+-- include type-checker plugins, source plugins, and core-to-core plugins.++module GHC.Driver.Plugins (+      -- * Plugins+      Plugin(..)+    , defaultPlugin+    , CommandLineOption+      -- ** Recompilation checking+    , purePlugin, impurePlugin, flagRecompile+    , PluginRecompile(..)++      -- * Plugin types+      -- ** Frontend plugins+    , FrontendPlugin(..), defaultFrontendPlugin, FrontendPluginAction+      -- ** Core plugins+      -- | Core plugins allow plugins to register as a Core-to-Core pass.+    , CorePlugin+      -- ** Typechecker plugins+      -- | Typechecker plugins allow plugins to provide evidence to the+      -- typechecker.+    , TcPlugin+      -- ** Source plugins+      -- | GHC offers a number of points where plugins can access and modify its+      -- front-end (\"source\") representation. These include:+      --+      -- - access to the parser result with 'parsedResultAction'+      -- - access to the renamed AST with 'renamedResultAction'+      -- - access to the typechecked AST with 'typeCheckResultAction'+      -- - access to the Template Haskell splices with 'spliceRunAction'+      -- - access to loaded interface files with 'interfaceLoadAction'+      --+    , keepRenamedSource+      -- ** Hole fit plugins+      -- | hole fit plugins allow plugins to change the behavior of valid hole+      -- fit suggestions+    , HoleFitPluginR++      -- * Internal+    , PluginWithArgs(..), plugins, pluginRecompile'+    , LoadedPlugin(..), lpModuleName+    , StaticPlugin(..)+    , mapPlugins, withPlugins, withPlugins_+    ) where++import GhcPrelude++import {-# SOURCE #-} CoreMonad ( CoreToDo, CoreM )+import qualified TcRnTypes+import TcRnTypes ( TcGblEnv, IfM, TcM, tcg_rn_decls, tcg_rn_exports  )+import TcHoleFitTypes ( HoleFitPluginR )+import GHC.Hs+import GHC.Driver.Session+import GHC.Driver.Types+import GHC.Driver.Monad+import GHC.Driver.Phases+import Module ( ModuleName, Module(moduleName))+import Fingerprint+import Data.List (sort)+import Outputable (Outputable(..), text, (<+>))++--Qualified import so we can define a Semigroup instance+-- but it doesn't clash with Outputable.<>+import qualified Data.Semigroup++import Control.Monad++-- | Command line options gathered from the -PModule.Name:stuff syntax+-- are given to you as this type+type CommandLineOption = String++-- | 'Plugin' is the compiler plugin data type. Try to avoid+-- constructing one of these directly, and just modify some fields of+-- 'defaultPlugin' instead: this is to try and preserve source-code+-- compatibility when we add fields to this.+--+-- Nonetheless, this API is preliminary and highly likely to change in+-- the future.+data Plugin = Plugin {+    installCoreToDos :: CorePlugin+    -- ^ Modify the Core pipeline that will be used for compilation.+    -- This is called as the Core pipeline is built for every module+    -- being compiled, and plugins get the opportunity to modify the+    -- pipeline in a nondeterministic order.+  , tcPlugin :: TcPlugin+    -- ^ An optional typechecker plugin, which may modify the+    -- behaviour of the constraint solver.+  , holeFitPlugin :: HoleFitPlugin+    -- ^ An optional plugin to handle hole fits, which may re-order+    --   or change the list of valid hole fits and refinement hole fits.+  , dynflagsPlugin :: [CommandLineOption] -> DynFlags -> IO DynFlags+    -- ^ An optional plugin to update 'DynFlags', right after+    --   plugin loading. This can be used to register hooks+    --   or tweak any field of 'DynFlags' before doing+    --   actual work on a module.+    --+    --   @since 8.10.1+  , pluginRecompile :: [CommandLineOption] -> IO PluginRecompile+    -- ^ Specify how the plugin should affect recompilation.+  , parsedResultAction :: [CommandLineOption] -> ModSummary -> HsParsedModule+                            -> Hsc HsParsedModule+    -- ^ Modify the module when it is parsed. This is called by+    -- GHC.Driver.Main when the parsing is successful.+  , renamedResultAction :: [CommandLineOption] -> TcGblEnv+                                -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)+    -- ^ Modify each group after it is renamed. This is called after each+    -- `HsGroup` has been renamed.+  , typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv+                               -> TcM TcGblEnv+    -- ^ Modify the module when it is type checked. This is called at the+    -- very end of typechecking.+  , spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc+                         -> TcM (LHsExpr GhcTc)+    -- ^ Modify the TH splice or quasiqoute before it is run.+  , interfaceLoadAction :: forall lcl . [CommandLineOption] -> ModIface+                                          -> IfM lcl ModIface+    -- ^ Modify an interface that have been loaded. This is called by+    -- GHC.Iface.Load when an interface is successfully loaded. Not applied to+    -- the loading of the plugin interface. Tools that rely on information from+    -- modules other than the currently compiled one should implement this+    -- function.+  }++-- Note [Source plugins]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- The `Plugin` datatype have been extended by fields that allow access to the+-- different inner representations that are generated during the compilation+-- process. These fields are `parsedResultAction`, `renamedResultAction`,+-- `typeCheckResultAction`, `spliceRunAction` and `interfaceLoadAction`.+--+-- The main purpose of these plugins is to help tool developers. They allow+-- development tools to extract the information about the source code of a big+-- Haskell project during the normal build procedure. In this case the plugin+-- acts as the tools access point to the compiler that can be controlled by+-- compiler flags. This is important because the manipulation of compiler flags+-- is supported by most build environment.+--+-- For the full discussion, check the full proposal at:+-- https://gitlab.haskell.org/ghc/ghc/wikis/extended-plugins-proposal++data PluginWithArgs = PluginWithArgs+  { paPlugin :: Plugin+    -- ^ the actual callable plugin+  , paArguments :: [CommandLineOption]+    -- ^ command line arguments for the plugin+  }++-- | A plugin with its arguments. The result of loading the plugin.+data LoadedPlugin = LoadedPlugin+  { lpPlugin :: PluginWithArgs+  -- ^ the actual plugin together with its commandline arguments+  , lpModule :: ModIface+  -- ^ the module containing the plugin+  }++-- | A static plugin with its arguments. For registering compiled-in plugins+-- through the GHC API.+data StaticPlugin = StaticPlugin+  { spPlugin :: PluginWithArgs+  -- ^ the actual plugin together with its commandline arguments+  }++lpModuleName :: LoadedPlugin -> ModuleName+lpModuleName = moduleName . mi_module . lpModule++pluginRecompile' :: PluginWithArgs -> IO PluginRecompile+pluginRecompile' (PluginWithArgs plugin args) = pluginRecompile plugin args++data PluginRecompile = ForceRecompile | NoForceRecompile | MaybeRecompile Fingerprint++instance Outputable PluginRecompile where+  ppr ForceRecompile = text "ForceRecompile"+  ppr NoForceRecompile = text "NoForceRecompile"+  ppr (MaybeRecompile fp) = text "MaybeRecompile" <+> ppr fp++instance Semigroup PluginRecompile where+  ForceRecompile <> _ = ForceRecompile+  NoForceRecompile <> r = r+  MaybeRecompile fp <> NoForceRecompile   = MaybeRecompile fp+  MaybeRecompile fp <> MaybeRecompile fp' = MaybeRecompile (fingerprintFingerprints [fp, fp'])+  MaybeRecompile _fp <> ForceRecompile     = ForceRecompile++instance Monoid PluginRecompile where+  mempty = NoForceRecompile++type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]+type TcPlugin = [CommandLineOption] -> Maybe TcRnTypes.TcPlugin+type HoleFitPlugin = [CommandLineOption] -> Maybe HoleFitPluginR++purePlugin, impurePlugin, flagRecompile :: [CommandLineOption] -> IO PluginRecompile+purePlugin _args = return NoForceRecompile++impurePlugin _args = return ForceRecompile++flagRecompile =+  return . MaybeRecompile . fingerprintFingerprints . map fingerprintString . sort++-- | Default plugin: does nothing at all, except for marking that safe+-- inference has failed unless @-fplugin-trustworthy@ is passed. For+-- compatibility reason you should base all your plugin definitions on this+-- default value.+defaultPlugin :: Plugin+defaultPlugin = Plugin {+        installCoreToDos      = const return+      , tcPlugin              = const Nothing+      , holeFitPlugin         = const Nothing+      , dynflagsPlugin        = const return+      , pluginRecompile       = impurePlugin+      , renamedResultAction   = \_ env grp -> return (env, grp)+      , parsedResultAction    = \_ _ -> return+      , typeCheckResultAction = \_ _ -> return+      , spliceRunAction       = \_ -> return+      , interfaceLoadAction   = \_ -> return+    }+++-- | A renamer plugin which mades the renamed source available in+-- a typechecker plugin.+keepRenamedSource :: [CommandLineOption] -> TcGblEnv+                  -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)+keepRenamedSource _ gbl_env group =+  return (gbl_env { tcg_rn_decls = update (tcg_rn_decls gbl_env)+                  , tcg_rn_exports = update_exports (tcg_rn_exports gbl_env) }, group)+  where+    update_exports Nothing = Just []+    update_exports m = m++    update Nothing = Just emptyRnGroup+    update m       = m+++type PluginOperation m a = Plugin -> [CommandLineOption] -> a -> m a+type ConstPluginOperation m a = Plugin -> [CommandLineOption] -> a -> m ()++plugins :: DynFlags -> [PluginWithArgs]+plugins df =+  map lpPlugin (cachedPlugins df) +++  map spPlugin (staticPlugins df)++-- | Perform an operation by using all of the plugins in turn.+withPlugins :: Monad m => DynFlags -> PluginOperation m a -> a -> m a+withPlugins df transformation input = foldM go input (plugins df)+  where+    go arg (PluginWithArgs p opts) = transformation p opts arg++mapPlugins :: DynFlags -> (Plugin -> [CommandLineOption] -> a) -> [a]+mapPlugins df f = map (\(PluginWithArgs p opts) -> f p opts) (plugins df)++-- | Perform a constant operation by using all of the plugins in turn.+withPlugins_ :: Monad m => DynFlags -> ConstPluginOperation m a -> a -> m ()+withPlugins_ df transformation input+  = mapM_ (\(PluginWithArgs p opts) -> transformation p opts input)+          (plugins df)++type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()+data FrontendPlugin = FrontendPlugin {+      frontend :: FrontendPluginAction+    }+defaultFrontendPlugin :: FrontendPlugin+defaultFrontendPlugin = FrontendPlugin { frontend = \_ _ -> return () }

+ compiler/GHC/Driver/Plugins.hs-boot view

@@ -0,0 +1,10 @@+-- The plugins datatype is stored in DynFlags, so it needs to be+-- exposed without importing all of its implementation.+module GHC.Driver.Plugins where++import GhcPrelude ()++data Plugin++data LoadedPlugin+data StaticPlugin

+ compiler/GHC/Driver/Session.hs view

@@ -0,0 +1,5939 @@+{-# OPTIONS_GHC -O0 #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE RankNTypes #-}++-------------------------------------------------------------------------------+--+-- | Dynamic flags+--+-- Most flags are dynamic flags, which means they can change from compilation+-- to compilation using @OPTIONS_GHC@ pragmas, and in a multi-session GHC each+-- session can be using different dynamic flags. Dynamic flags can also be set+-- at the prompt in GHCi.+--+-- (c) The University of Glasgow 2005+--+-------------------------------------------------------------------------------++{-# OPTIONS_GHC -fno-cse #-}+-- -fno-cse is needed for GLOBAL_VAR's to behave properly+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++module GHC.Driver.Session (+        -- * Dynamic flags and associated configuration types+        DumpFlag(..),+        GeneralFlag(..),+        WarningFlag(..), WarnReason(..),+        Language(..),+        PlatformConstants(..),+        FatalMessager, LogAction, FlushOut(..), FlushErr(..),+        ProfAuto(..),+        glasgowExtsFlags,+        warningGroups, warningHierarchies,+        hasPprDebug, hasNoDebugOutput, hasNoStateHack, hasNoOptCoercion,+        dopt, dopt_set, dopt_unset,+        gopt, gopt_set, gopt_unset, setGeneralFlag', unSetGeneralFlag',+        wopt, wopt_set, wopt_unset,+        wopt_fatal, wopt_set_fatal, wopt_unset_fatal,+        xopt, xopt_set, xopt_unset,+        xopt_set_unlessExplSpec,+        lang_set,+        whenGeneratingDynamicToo, ifGeneratingDynamicToo,+        whenCannotGenerateDynamicToo,+        dynamicTooMkDynamicDynFlags,+        dynamicOutputFile,+        DynFlags(..),+        FlagSpec(..),+        HasDynFlags(..), ContainsDynFlags(..),+        RtsOptsEnabled(..),+        HscTarget(..), isObjectTarget, defaultObjectTarget,+        targetRetainsAllBindings,+        GhcMode(..), isOneShot,+        GhcLink(..), isNoLink,+        PackageFlag(..), PackageArg(..), ModRenaming(..),+        packageFlagsChanged,+        IgnorePackageFlag(..), TrustFlag(..),+        PackageDBFlag(..), PkgDbRef(..),+        Option(..), showOpt,+        DynLibLoader(..),+        fFlags, fLangFlags, xFlags,+        wWarningFlags,+        dynFlagDependencies,+        makeDynFlagsConsistent,+        positionIndependent,+        optimisationFlags,+        setFlagsFromEnvFile,++        Way(..), mkBuildTag, wayRTSOnly, addWay', updateWays,+        wayGeneralFlags, wayUnsetGeneralFlags,++        thisPackage, thisComponentId, thisUnitIdInsts,++        -- ** Log output+        putLogMsg,++        -- ** Safe Haskell+        SafeHaskellMode(..),+        safeHaskellOn, safeHaskellModeEnabled,+        safeImportsOn, safeLanguageOn, safeInferOn,+        packageTrustOn,+        safeDirectImpsReq, safeImplicitImpsReq,+        unsafeFlags, unsafeFlagsForInfer,++        -- ** LLVM Targets+        LlvmTarget(..), LlvmConfig(..),++        -- ** System tool settings and locations+        Settings(..),+        sProgramName,+        sProjectVersion,+        sGhcUsagePath,+        sGhciUsagePath,+        sToolDir,+        sTopDir,+        sTmpDir,+        sGlobalPackageDatabasePath,+        sLdSupportsCompactUnwind,+        sLdSupportsBuildId,+        sLdSupportsFilelist,+        sLdIsGnuLd,+        sGccSupportsNoPie,+        sPgm_L,+        sPgm_P,+        sPgm_F,+        sPgm_c,+        sPgm_a,+        sPgm_l,+        sPgm_dll,+        sPgm_T,+        sPgm_windres,+        sPgm_libtool,+        sPgm_ar,+        sPgm_ranlib,+        sPgm_lo,+        sPgm_lc,+        sPgm_lcc,+        sPgm_i,+        sOpt_L,+        sOpt_P,+        sOpt_P_fingerprint,+        sOpt_F,+        sOpt_c,+        sOpt_cxx,+        sOpt_a,+        sOpt_l,+        sOpt_windres,+        sOpt_lo,+        sOpt_lc,+        sOpt_lcc,+        sOpt_i,+        sExtraGccViaCFlags,+        sTargetPlatformString,+        sIntegerLibrary,+        sIntegerLibraryType,+        sGhcWithInterpreter,+        sGhcWithNativeCodeGen,+        sGhcWithSMP,+        sGhcRTSWays,+        sTablesNextToCode,+        sLeadingUnderscore,+        sLibFFI,+        sGhcThreaded,+        sGhcDebugged,+        sGhcRtsWithLibdw,+        IntegerLibrary(..),+        GhcNameVersion(..),+        FileSettings(..),+        PlatformMisc(..),+        settings,+        programName, projectVersion,+        ghcUsagePath, ghciUsagePath, topDir, tmpDir,+        versionedAppDir, versionedFilePath,+        extraGccViaCFlags, globalPackageDatabasePath,+        pgm_L, pgm_P, pgm_F, pgm_c, pgm_a, pgm_l, pgm_dll, pgm_T,+        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_cxx, opt_a, opt_l, opt_i,+        opt_P_signature,+        opt_windres, opt_lo, opt_lc, opt_lcc,+        tablesNextToCode,++        -- ** Manipulating DynFlags+        addPluginModuleName,+        defaultDynFlags,                -- Settings -> DynFlags+        defaultWays,+        interpWays,+        interpreterProfiled, interpreterDynamic,+        initDynFlags,                   -- DynFlags -> IO DynFlags+        defaultFatalMessager,+        defaultLogAction,+        defaultLogActionHPrintDoc,+        defaultLogActionHPutStrDoc,+        defaultFlushOut,+        defaultFlushErr,++        getOpts,                        -- DynFlags -> (DynFlags -> [a]) -> [a]+        getVerbFlags,+        updOptLevel,+        setTmpDir,+        setUnitId,+        canonicalizeHomeModule,+        canonicalizeModuleIfHome,++        -- ** Parsing DynFlags+        parseDynamicFlagsCmdLine,+        parseDynamicFilePragma,+        parseDynamicFlagsFull,++        -- ** Available DynFlags+        allNonDeprecatedFlags,+        flagsAll,+        flagsDynamic,+        flagsPackage,+        flagsForCompletion,++        supportedLanguagesAndExtensions,+        languageExtensions,++        -- ** DynFlags C compiler options+        picCCOpts, picPOpts,++        -- * Compiler configuration suitable for display to the user+        compilerInfo,++        rtsIsProfiled,+        dynamicGhc,++#include "GHCConstantsHaskellExports.hs"+        bLOCK_SIZE_W,+        wORD_SIZE_IN_BITS,+        wordAlignment,+        tAG_MASK,+        mAX_PTR_TAG,+        tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD,++        unsafeGlobalDynFlags, setUnsafeGlobalDynFlags,++        -- * SSE and AVX+        isSseEnabled,+        isSse2Enabled,+        isSse4_2Enabled,+        isBmiEnabled,+        isBmi2Enabled,+        isAvxEnabled,+        isAvx2Enabled,+        isAvx512cdEnabled,+        isAvx512erEnabled,+        isAvx512fEnabled,+        isAvx512pfEnabled,++        -- * Linker/compiler information+        LinkerInfo(..),+        CompilerInfo(..),++        -- * File cleanup+        FilesToClean(..), emptyFilesToClean,++        -- * Include specifications+        IncludeSpecs(..), addGlobalInclude, addQuoteInclude, flattenIncludes,++        -- * SDoc+        initSDocContext,++        -- * Make use of the Cmm CFG+        CfgWeights(..), backendMaintainsCfg+  ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.Platform+import GHC.UniqueSubdir (uniqueSubdir)+import PlatformConstants+import Module+import {-# SOURCE #-} GHC.Driver.Plugins+import {-# SOURCE #-} GHC.Driver.Hooks+import {-# SOURCE #-} PrelNames ( mAIN )+import {-# SOURCE #-} GHC.Driver.Packages (PackageState, emptyPackageState, PackageDatabase)+import GHC.Driver.Phases ( Phase(..), phaseInputExt )+import Config+import CliOption+import GHC.Driver.CmdLine hiding (WarnReason(..))+import qualified GHC.Driver.CmdLine as Cmd+import Constants+import GhcNameVersion+import Panic+import qualified PprColour as Col+import Util+import Maybes+import MonadUtils+import qualified Pretty+import SrcLoc+import BasicTypes       ( Alignment, alignmentOf, IntWithInf, treatZeroAsInf )+import FastString+import Fingerprint+import FileSettings+import Outputable+import Settings+import ToolSettings++import Foreign.C        ( CInt(..) )+import System.IO.Unsafe ( unsafeDupablePerformIO )+import {-# SOURCE #-} ErrUtils ( Severity(..), MsgDoc, mkLocMessageAnn+                               , getCaretDiagnostic, DumpAction, TraceAction+                               , defaultDumpAction, defaultTraceAction )+import Json+import SysTools.Terminal ( stderrSupportsAnsiColors )+import SysTools.BaseDir ( expandToolDir, expandTopDir )++import System.IO.Unsafe ( unsafePerformIO )+import Data.IORef+import Control.Arrow ((&&&))+import Control.Monad+import Control.Monad.Trans.Class+import Control.Monad.Trans.Writer+import Control.Monad.Trans.Reader+import Control.Monad.Trans.Except++import Data.Ord+import Data.Bits+import Data.Char+import Data.Int+import Data.List+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Set (Set)+import qualified Data.Set as Set+import Data.Word+import System.FilePath+import System.Directory+import System.Environment (lookupEnv)+import System.IO+import System.IO.Error+import Text.ParserCombinators.ReadP hiding (char)+import Text.ParserCombinators.ReadP as R++import EnumSet (EnumSet)+import qualified EnumSet++import GHC.Foreign (withCString, peekCString)+import qualified GHC.LanguageExtensions as LangExt++#if GHC_STAGE >= 2+-- used by SHARED_GLOBAL_VAR+import Foreign (Ptr)+#endif++-- Note [Updating flag description in the User's Guide]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- If you modify anything in this file please make sure that your changes are+-- 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]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- The command line interface completion (in for example bash) is an easy way+-- for the developer to learn what flags are available from GHC.+-- GHC helps by separating which flags are available when compiling with GHC,+-- and which flags are available when using GHCi.+-- A flag is assumed to either work in both these modes, or only in one of them.+-- When adding or changing a flag, please consider for which mode the flag will+-- have effect, and annotate it accordingly. For Flags use defFlag, defGhcFlag,+-- defGhciFlag, and for FlagSpec use flagSpec or flagGhciSpec.++-- Note [Adding a language extension]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- There are a few steps to adding (or removing) a language extension,+--+--  * Adding the extension to GHC.LanguageExtensions+--+--    The Extension type in libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs+--    is the canonical list of language extensions known by GHC.+--+--  * Adding a flag to DynFlags.xFlags+--+--    This is fairly self-explanatory. The name should be concise, memorable,+--    and consistent with any previous implementations of the similar idea in+--    other Haskell compilers.+--+--  * Adding the flag to the documentation+--+--    This is the same as any other flag. See+--    Note [Updating flag description in the User's Guide]+--+--  * Adding the flag to Cabal+--+--    The Cabal library has its own list of all language extensions supported+--    by all major compilers. This is the list that user code being uploaded+--    to Hackage is checked against to ensure language extension validity.+--    Consequently, it is very important that this list remains up-to-date.+--+--    To this end, there is a testsuite test (testsuite/tests/driver/T4437.hs)+--    whose job it is to ensure these GHC's extensions are consistent with+--    Cabal.+--+--    The recommended workflow is,+--+--     1. Temporarily add your new language extension to the+--        expectedGhcOnlyExtensions list in T4437 to ensure the test doesn't+--        break while Cabal is updated.+--+--     2. After your GHC change is accepted, submit a Cabal pull request adding+--        your new extension to Cabal's list (found in+--        Cabal/Language/Haskell/Extension.hs).+--+--     3. After your Cabal change is accepted, let the GHC developers know so+--        they can update the Cabal submodule and remove the extensions from+--        expectedGhcOnlyExtensions.+--+--  * Adding the flag to the GHC Wiki+--+--    There is a change log tracking language extension additions and removals+--    on the GHC wiki:  https://gitlab.haskell.org/ghc/ghc/wikis/language-pragma-history+--+--  See #4437 and #8176.++-- -----------------------------------------------------------------------------+-- DynFlags++data DumpFlag+-- See Note [Updating flag description in the User's Guide]++   -- debugging flags+   = Opt_D_dump_cmm+   | Opt_D_dump_cmm_from_stg+   | Opt_D_dump_cmm_raw+   | Opt_D_dump_cmm_verbose_by_proc+   -- All of the cmm subflags (there are a lot!) automatically+   -- enabled if you run -ddump-cmm-verbose-by-proc+   -- Each flag corresponds to exact stage of Cmm pipeline.+   | Opt_D_dump_cmm_verbose+   -- same as -ddump-cmm-verbose-by-proc but writes each stage+   -- to a separate file (if used with -ddump-to-file)+   | Opt_D_dump_cmm_cfg+   | Opt_D_dump_cmm_cbe+   | Opt_D_dump_cmm_switch+   | Opt_D_dump_cmm_proc+   | Opt_D_dump_cmm_sp+   | Opt_D_dump_cmm_sink+   | Opt_D_dump_cmm_caf+   | Opt_D_dump_cmm_procmap+   | Opt_D_dump_cmm_split+   | Opt_D_dump_cmm_info+   | Opt_D_dump_cmm_cps+   -- end cmm subflags+   | Opt_D_dump_cfg_weights -- ^ Dump the cfg used for block layout.+   | Opt_D_dump_asm+   | Opt_D_dump_asm_native+   | Opt_D_dump_asm_liveness+   | Opt_D_dump_asm_regalloc+   | Opt_D_dump_asm_regalloc_stages+   | Opt_D_dump_asm_conflicts+   | Opt_D_dump_asm_stats+   | Opt_D_dump_asm_expanded+   | Opt_D_dump_llvm+   | Opt_D_dump_core_stats+   | Opt_D_dump_deriv+   | Opt_D_dump_ds+   | Opt_D_dump_ds_preopt+   | Opt_D_dump_foreign+   | Opt_D_dump_inlinings+   | Opt_D_dump_rule_firings+   | Opt_D_dump_rule_rewrites+   | Opt_D_dump_simpl_trace+   | Opt_D_dump_occur_anal+   | Opt_D_dump_parsed+   | Opt_D_dump_parsed_ast+   | Opt_D_dump_rn+   | Opt_D_dump_rn_ast+   | Opt_D_dump_simpl+   | Opt_D_dump_simpl_iterations+   | Opt_D_dump_spec+   | Opt_D_dump_prep+   | Opt_D_dump_stg -- CoreToStg output+   | Opt_D_dump_stg_unarised -- STG after unarise+   | Opt_D_dump_stg_final -- STG after stg2stg+   | Opt_D_dump_call_arity+   | Opt_D_dump_exitify+   | Opt_D_dump_stranal+   | Opt_D_dump_str_signatures+   | Opt_D_dump_cpranal+   | Opt_D_dump_cpr_signatures+   | Opt_D_dump_tc+   | Opt_D_dump_tc_ast+   | Opt_D_dump_types+   | Opt_D_dump_rules+   | Opt_D_dump_cse+   | Opt_D_dump_worker_wrapper+   | Opt_D_dump_rn_trace+   | Opt_D_dump_rn_stats+   | Opt_D_dump_opt_cmm+   | Opt_D_dump_simpl_stats+   | Opt_D_dump_cs_trace -- Constraint solver in type checker+   | Opt_D_dump_tc_trace+   | Opt_D_dump_ec_trace -- Pattern match exhaustiveness checker+   | Opt_D_dump_if_trace+   | Opt_D_dump_vt_trace+   | Opt_D_dump_splices+   | Opt_D_th_dec_file+   | Opt_D_dump_BCOs+   | Opt_D_dump_ticked+   | Opt_D_dump_rtti+   | Opt_D_source_stats+   | Opt_D_verbose_stg2stg+   | Opt_D_dump_hi+   | 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+   | Opt_D_dump_json+   | Opt_D_ppr_debug+   | 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]++   = Opt_DumpToFile                     -- ^ Append dump output to files instead of stdout.+   | Opt_D_faststring_stats+   | Opt_D_dump_minimal_imports+   | Opt_DoCoreLinting+   | Opt_DoStgLinting+   | Opt_DoCmmLinting+   | Opt_DoAsmLinting+   | Opt_DoAnnotationLinting+   | Opt_NoLlvmMangler                  -- hidden flag+   | Opt_FastLlvm                       -- hidden flag+   | Opt_NoTypeableBinds++   | Opt_WarnIsError                    -- -Werror; makes warnings fatal+   | Opt_ShowWarnGroups                 -- Show the group a warning belongs to+   | Opt_HideSourcePaths                -- Hide module source/object paths++   | Opt_PrintExplicitForalls+   | Opt_PrintExplicitKinds+   | Opt_PrintExplicitCoercions+   | Opt_PrintExplicitRuntimeReps+   | Opt_PrintEqualityRelations+   | Opt_PrintAxiomIncomps+   | Opt_PrintUnicodeSyntax+   | Opt_PrintExpandedSynonyms+   | Opt_PrintPotentialInstances+   | Opt_PrintTypecheckerElaboration++   -- optimisation opts+   | Opt_CallArity+   | Opt_Exitification+   | Opt_Strictness+   | Opt_LateDmdAnal                    -- #6087+   | Opt_KillAbsence+   | Opt_KillOneShot+   | Opt_FullLaziness+   | Opt_FloatIn+   | Opt_LateSpecialise+   | Opt_Specialise+   | Opt_SpecialiseAggressively+   | Opt_CrossModuleSpecialise+   | Opt_StaticArgumentTransformation+   | Opt_CSE+   | Opt_StgCSE+   | Opt_StgLiftLams+   | Opt_LiberateCase+   | Opt_SpecConstr+   | Opt_SpecConstrKeen+   | Opt_DoLambdaEtaExpansion+   | Opt_IgnoreAsserts+   | Opt_DoEtaReduction+   | Opt_CaseMerge+   | Opt_CaseFolding                    -- Constant folding through case-expressions+   | Opt_UnboxStrictFields+   | Opt_UnboxSmallStrictFields+   | Opt_DictsCheap+   | Opt_EnableRewriteRules             -- Apply rewrite rules during simplification+   | Opt_EnableThSpliceWarnings         -- Enable warnings for TH splices+   | Opt_RegsGraph                      -- do graph coloring register allocation+   | Opt_RegsIterative                  -- do iterative coalescing graph coloring register allocation+   | Opt_PedanticBottoms                -- Be picky about how we treat bottom+   | Opt_LlvmTBAA                       -- Use LLVM TBAA infrastructure for improving AA (hidden flag)+   | Opt_LlvmFillUndefWithGarbage       -- Testing for undef bugs (hidden flag)+   | Opt_IrrefutableTuples+   | Opt_CmmSink+   | Opt_CmmElimCommonBlocks+   | Opt_AsmShortcutting+   | Opt_OmitYields+   | Opt_FunToThunk               -- allow WwLib.mkWorkerArgs to remove all value lambdas+   | Opt_DictsStrict                     -- be strict in argument dictionaries+   | Opt_DmdTxDictSel              -- use a special demand transformer for dictionary selectors+   | Opt_Loopification                  -- See Note [Self-recursive tail calls]+   | Opt_CfgBlocklayout             -- ^ Use the cfg based block layout algorithm.+   | Opt_WeightlessBlocklayout         -- ^ Layout based on last instruction per block.+   | Opt_CprAnal+   | Opt_WorkerWrapper+   | Opt_SolveConstantDicts+   | Opt_AlignmentSanitisation+   | Opt_CatchBottoms+   | Opt_NumConstantFolding++   -- 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+   | Opt_ExposeAllUnfoldings+   | Opt_WriteInterface -- forces .hi files to be written even with -fno-code+   | Opt_WriteHie -- generate .hie files++   -- profiling opts+   | Opt_AutoSccsOnIndividualCafs+   | Opt_ProfCountEntries++   -- misc opts+   | Opt_Pp+   | Opt_ForceRecomp+   | Opt_IgnoreOptimChanges+   | Opt_IgnoreHpcChanges+   | Opt_ExcessPrecision+   | Opt_EagerBlackHoling+   | Opt_NoHsMain+   | Opt_SplitSections+   | Opt_StgStats+   | Opt_HideAllPackages+   | Opt_HideAllPluginPackages+   | Opt_PrintBindResult+   | Opt_Haddock+   | Opt_HaddockOptions+   | Opt_BreakOnException+   | Opt_BreakOnError+   | Opt_PrintEvldWithShow+   | Opt_PrintBindContents+   | Opt_GenManifest+   | Opt_EmbedManifest+   | Opt_SharedImplib+   | Opt_BuildingCabalPackage+   | Opt_IgnoreDotGhci+   | Opt_GhciSandbox+   | Opt_GhciHistory+   | Opt_GhciLeakCheck+   | Opt_ValidateHie+   | Opt_LocalGhciHistory+   | Opt_NoIt+   | Opt_HelpfulErrors+   | Opt_DeferTypeErrors+   | Opt_DeferTypedHoles+   | Opt_DeferOutOfScopeVariables+   | Opt_PIC                         -- ^ @-fPIC@+   | Opt_PIE                         -- ^ @-fPIE@+   | Opt_PICExecutable               -- ^ @-pie@+   | Opt_ExternalDynamicRefs+   | Opt_SccProfilingOn+   | Opt_Ticky+   | Opt_Ticky_Allocd+   | Opt_Ticky_LNE+   | Opt_Ticky_Dyn_Thunk+   | Opt_RPath+   | Opt_RelativeDynlibPaths+   | Opt_Hpc+   | Opt_FlatCache+   | Opt_ExternalInterpreter+   | Opt_OptimalApplicativeDo+   | Opt_VersionMacros+   | Opt_WholeArchiveHsLibs+   -- copy all libs into a single folder prior to linking binaries+   -- this should elivate the excessive command line limit restrictions+   -- on windows, by only requiring a single -L argument instead of+   -- one for each dependency.  At the time of this writing, gcc+   -- forwards all -L flags to the collect2 command without using a+   -- response file and as such breaking apart.+   | Opt_SingleLibFolder+   | Opt_KeepCAFs+   | Opt_KeepGoing+   | Opt_ByteCode++   -- output style opts+   | Opt_ErrorSpans -- Include full span info in error messages,+                    -- instead of just the start position.+   | Opt_DeferDiagnostics+   | Opt_DiagnosticsShowCaret -- Show snippets of offending code+   | Opt_PprCaseAsLet+   | Opt_PprShowTicks+   | Opt_ShowHoleConstraints+    -- Options relating to the display of valid hole fits+    -- when generating an error message for a typed hole+    -- See Note [Valid hole fits include] in TcHoleErrors.hs+   | Opt_ShowValidHoleFits+   | Opt_SortValidHoleFits+   | Opt_SortBySizeHoleFits+   | Opt_SortBySubsumHoleFits+   | Opt_AbstractRefHoleFits+   | Opt_UnclutterValidHoleFits+   | Opt_ShowTypeAppOfHoleFits+   | Opt_ShowTypeAppVarsOfHoleFits+   | Opt_ShowDocsOfHoleFits+   | Opt_ShowTypeOfHoleFits+   | Opt_ShowProvOfHoleFits+   | Opt_ShowMatchesOfHoleFits++   | Opt_ShowLoadedModules+   | Opt_HexWordLiterals -- See Note [Print Hexadecimal Literals]++   -- Suppress all coercions, them replacing with '...'+   | Opt_SuppressCoercions+   | Opt_SuppressVarKinds+   -- Suppress module id prefixes on variables.+   | Opt_SuppressModulePrefixes+   -- Suppress type applications.+   | Opt_SuppressTypeApplications+   -- Suppress info such as arity and unfoldings on identifiers.+   | Opt_SuppressIdInfo+   -- Suppress separate type signatures in core, but leave types on+   -- lambda bound vars+   | Opt_SuppressUnfoldings+   -- Suppress the details of even stable unfoldings+   | Opt_SuppressTypeSignatures+   -- Suppress unique ids on variables.+   -- Except for uniques, as some simplifier phases introduce new+   -- variables that have otherwise identical names.+   | Opt_SuppressUniques+   | Opt_SuppressStgExts+   | Opt_SuppressTicks     -- Replaces Opt_PprShowTicks+   | Opt_SuppressTimestamps -- ^ Suppress timestamps in dumps++   -- temporary flags+   | Opt_AutoLinkPackages+   | Opt_ImplicitImportQualified++   -- keeping stuff+   | Opt_KeepHscppFiles+   | Opt_KeepHiDiffs+   | Opt_KeepHcFiles+   | Opt_KeepSFiles+   | Opt_KeepTmpFiles+   | Opt_KeepRawTokenStream+   | Opt_KeepLlvmFiles+   | Opt_KeepHiFiles+   | Opt_KeepOFiles++   | Opt_BuildDynamicToo++   -- safe haskell flags+   | Opt_DistrustAllPackages+   | Opt_PackageTrust+   | Opt_PluginTrustworthy++   | Opt_G_NoStateHack+   | 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_LateSpecialise+   , Opt_Specialise+   , Opt_SpecialiseAggressively+   , Opt_CrossModuleSpecialise+   , Opt_StaticArgumentTransformation+   , Opt_CSE+   , Opt_StgCSE+   , Opt_StgLiftLams+   , 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_RegsGraph+   , Opt_RegsIterative+   , Opt_PedanticBottoms+   , Opt_LlvmTBAA+   , Opt_LlvmFillUndefWithGarbage+   , Opt_IrrefutableTuples+   , Opt_CmmSink+   , Opt_CmmElimCommonBlocks+   , Opt_AsmShortcutting+   , Opt_OmitYields+   , Opt_FunToThunk+   , Opt_DictsStrict+   , Opt_DmdTxDictSel+   , Opt_Loopification+   , Opt_CfgBlocklayout+   , Opt_WeightlessBlocklayout+   , 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+  -- | Warning was enabled with the flag+  | Reason !WarningFlag+  -- | Warning was made an error because of -Werror or -Werror=WarningFlag+  | ErrReason !(Maybe WarningFlag)+  deriving Show++-- | Used to differentiate the scope an include needs to apply to.+-- We have to split the include paths to avoid accidentally forcing recursive+-- includes since -I overrides the system search paths. See #14312.+data IncludeSpecs+  = IncludeSpecs { includePathsQuote  :: [String]+                 , includePathsGlobal :: [String]+                 }+  deriving Show++-- | Append to the list of includes a path that shall be included using `-I`+-- when the C compiler is called. These paths override system search paths.+addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs+addGlobalInclude spec paths  = let f = includePathsGlobal spec+                               in spec { includePathsGlobal = f ++ paths }++-- | Append to the list of includes a path that shall be included using+-- `-iquote` when the C compiler is called. These paths only apply when quoted+-- includes are used. e.g. #include "foo.h"+addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs+addQuoteInclude spec paths  = let f = includePathsQuote spec+                              in spec { includePathsQuote = f ++ paths }++-- | Concatenate and flatten the list of global and quoted includes returning+-- just a flat list of paths.+flattenIncludes :: IncludeSpecs -> [String]+flattenIncludes specs = includePathsQuote specs ++ includePathsGlobal specs++instance Outputable WarnReason where+  ppr = text . show++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]+     Opt_WarnDuplicateExports+   | Opt_WarnDuplicateConstraints+   | Opt_WarnRedundantConstraints+   | Opt_WarnHiShadows+   | Opt_WarnImplicitPrelude+   | Opt_WarnIncompletePatterns+   | Opt_WarnIncompleteUniPatterns+   | Opt_WarnIncompletePatternsRecUpd+   | Opt_WarnOverflowedLiterals+   | Opt_WarnEmptyEnumerations+   | Opt_WarnMissingFields+   | Opt_WarnMissingImportList+   | Opt_WarnMissingMethods+   | Opt_WarnMissingSignatures+   | Opt_WarnMissingLocalSignatures+   | Opt_WarnNameShadowing+   | Opt_WarnOverlappingPatterns+   | Opt_WarnTypeDefaults+   | Opt_WarnMonomorphism+   | Opt_WarnUnusedTopBinds+   | Opt_WarnUnusedLocalBinds+   | Opt_WarnUnusedPatternBinds+   | Opt_WarnUnusedImports+   | Opt_WarnUnusedMatches+   | Opt_WarnUnusedTypePatterns+   | Opt_WarnUnusedForalls+   | Opt_WarnUnusedRecordWildcards+   | Opt_WarnRedundantRecordWildcards+   | Opt_WarnWarningsDeprecations+   | Opt_WarnDeprecatedFlags+   | Opt_WarnMissingMonadFailInstances -- since 8.0, has no effect since 8.8+   | Opt_WarnSemigroup -- since 8.0+   | Opt_WarnDodgyExports+   | Opt_WarnDodgyImports+   | Opt_WarnOrphans+   | Opt_WarnAutoOrphans+   | Opt_WarnIdentities+   | Opt_WarnTabs+   | Opt_WarnUnrecognisedPragmas+   | Opt_WarnDodgyForeignImports+   | Opt_WarnUnusedDoBind+   | Opt_WarnWrongDoBind+   | Opt_WarnAlternativeLayoutRuleTransitional+   | Opt_WarnUnsafe+   | Opt_WarnSafe+   | Opt_WarnTrustworthySafe+   | Opt_WarnMissedSpecs+   | Opt_WarnAllMissedSpecs+   | Opt_WarnUnsupportedCallingConventions+   | Opt_WarnUnsupportedLlvmVersion+   | Opt_WarnMissedExtraSharedLib+   | Opt_WarnInlineRuleShadowing+   | Opt_WarnTypedHoles+   | Opt_WarnPartialTypeSignatures+   | Opt_WarnMissingExportedSignatures+   | Opt_WarnUntickedPromotedConstructors+   | Opt_WarnDerivingTypeable+   | Opt_WarnDeferredTypeErrors+   | Opt_WarnDeferredOutOfScopeVariables+   | Opt_WarnNonCanonicalMonadInstances   -- since 8.0+   | Opt_WarnNonCanonicalMonadFailInstances   -- since 8.0, removed 8.8+   | Opt_WarnNonCanonicalMonoidInstances  -- since 8.0+   | Opt_WarnMissingPatternSynonymSignatures -- since 8.0+   | Opt_WarnUnrecognisedWarningFlags     -- since 8.0+   | Opt_WarnSimplifiableClassConstraints -- Since 8.2+   | Opt_WarnCPPUndef                     -- Since 8.2+   | Opt_WarnUnbangedStrictPatterns       -- Since 8.2+   | Opt_WarnMissingHomeModules           -- Since 8.2+   | Opt_WarnPartialFields                -- Since 8.4+   | Opt_WarnMissingExportList+   | Opt_WarnInaccessibleCode+   | Opt_WarnStarIsType                   -- Since 8.6+   | Opt_WarnStarBinder                   -- Since 8.6+   | Opt_WarnImplicitKindVars             -- Since 8.6+   | Opt_WarnSpaceAfterBang+   | Opt_WarnMissingDerivingStrategies    -- Since 8.8+   | Opt_WarnPrepositiveQualifiedModule   -- Since TBD+   | Opt_WarnUnusedPackages               -- Since 8.10+   | Opt_WarnInferredSafeImports          -- Since 8.10+   | Opt_WarnMissingSafeHaskellMode       -- Since 8.10+   | Opt_WarnCompatUnqualifiedImports     -- Since 8.10+   | Opt_WarnDerivingDefaults+   deriving (Eq, Show, Enum)++data Language = Haskell98 | Haskell2010+   deriving (Eq, Enum, Show)++instance Outputable Language where+    ppr = text . show++-- | The various Safe Haskell modes+data SafeHaskellMode+   = Sf_None          -- ^ inferred unsafe+   | Sf_Unsafe        -- ^ declared and checked+   | Sf_Trustworthy   -- ^ declared and checked+   | Sf_Safe          -- ^ declared and checked+   | Sf_SafeInferred  -- ^ inferred as safe+   | Sf_Ignore        -- ^ @-fno-safe-haskell@ state+   deriving (Eq)++instance Show SafeHaskellMode where+    show Sf_None         = "None"+    show Sf_Unsafe       = "Unsafe"+    show Sf_Trustworthy  = "Trustworthy"+    show Sf_Safe         = "Safe"+    show Sf_SafeInferred = "Safe-Inferred"+    show Sf_Ignore       = "Ignore"++instance Outputable SafeHaskellMode where+    ppr = text . show++-- | Contains not only a collection of 'GeneralFlag's but also a plethora of+-- information relating to the compilation of a single file or GHC session+data DynFlags = DynFlags {+  ghcMode               :: GhcMode,+  ghcLink               :: GhcLink,+  hscTarget             :: HscTarget,++  -- formerly Settings+  ghcNameVersion    :: {-# UNPACK #-} !GhcNameVersion,+  fileSettings      :: {-# UNPACK #-} !FileSettings,+  targetPlatform    :: Platform,       -- Filled in by SysTools+  toolSettings      :: {-# UNPACK #-} !ToolSettings,+  platformMisc      :: {-# UNPACK #-} !PlatformMisc,+  platformConstants :: PlatformConstants,+  rawSettings       :: [(String, String)],++  integerLibrary        :: IntegerLibrary,+    -- ^ IntegerGMP or IntegerSimple. Set at configure time, but may be overridden+    --   by GHC-API users. See Note [The integer library] in PrelNames+  llvmConfig            :: LlvmConfig,+    -- ^ N.B. It's important that this field is lazy since we load the LLVM+    -- configuration lazily. See Note [LLVM Configuration] in SysTools.+  verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]+  optLevel              :: Int,         -- ^ Optimisation level+  debugLevel            :: Int,         -- ^ How much debug information to produce+  simplPhases           :: Int,         -- ^ Number of simplifier phases+  maxSimplIterations    :: Int,         -- ^ Max simplifier iterations+  ruleCheck             :: Maybe String,+  inlineCheck           :: Maybe String, -- ^ A prefix to report inlining decisions about+  strictnessBefore      :: [Int],       -- ^ Additional demand analysis++  parMakeCount          :: Maybe Int,   -- ^ The number of modules to compile in parallel+                                        --   in --make mode, where Nothing ==> compile as+                                        --   many in parallel as there are CPUs.++  enableTimeStats       :: Bool,        -- ^ Enable RTS timing statistics?+  ghcHeapSize           :: Maybe Int,   -- ^ The heap size to set.++  maxRelevantBinds      :: Maybe Int,   -- ^ Maximum number of bindings from the type envt+                                        --   to show in type error messages+  maxValidHoleFits      :: Maybe Int,   -- ^ Maximum number of hole fits to show+                                        --   in typed hole error messages+  maxRefHoleFits        :: Maybe Int,   -- ^ Maximum number of refinement hole+                                        --   fits to show in typed hole error+                                        --   messages+  refLevelHoleFits      :: Maybe Int,   -- ^ Maximum level of refinement for+                                        --   refinement hole fits in typed hole+                                        --   error messages+  maxUncoveredPatterns  :: Int,         -- ^ Maximum number of unmatched patterns to show+                                        --   in non-exhaustiveness warnings+  maxPmCheckModels      :: Int,         -- ^ Soft limit on the number of models+                                        --   the pattern match checker checks+                                        --   a pattern against. A safe guard+                                        --   against exponential blow-up.+  simplTickFactor       :: Int,         -- ^ Multiplier for simplifier ticks+  specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr+  specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function+  specConstrRecursive   :: Int,         -- ^ Max number of specialisations for recursive types+                                        --   Not optional; otherwise ForceSpecConstr can diverge.+  binBlobThreshold      :: Word,        -- ^ Binary literals (e.g. strings) whose size is above+                                        --   this threshold will be dumped in a binary file+                                        --   by the assembler code generator (0 to disable)+  liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase+  floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating+                                        --   See CoreMonad.FloatOutSwitches++  liftLamsRecArgs       :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a+                                        --   recursive function.+  liftLamsNonRecArgs    :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a+                                        --   non-recursive function.+  liftLamsKnown         :: Bool,        -- ^ Lambda lift even when this turns a known call+                                        --   into an unknown call.++  cmmProcAlignment      :: Maybe Int,   -- ^ Align Cmm functions at this boundary or use default.++  historySize           :: Int,         -- ^ Simplification history size++  importPaths           :: [FilePath],+  mainModIs             :: Module,+  mainFunIs             :: Maybe String,+  reductionDepth        :: IntWithInf,   -- ^ Typechecker maximum stack depth+  solverIterations      :: IntWithInf,   -- ^ Number of iterations in the constraints solver+                                         --   Typically only 1 is needed++  thisInstalledUnitId   :: InstalledUnitId,+  thisComponentId_      :: Maybe ComponentId,+  thisUnitIdInsts_      :: Maybe [(ModuleName, Module)],++  -- ways+  ways                  :: [Way],       -- ^ Way flags from the command line+  buildTag              :: String,      -- ^ The global \"way\" (e.g. \"p\" for prof)++  -- For object splitting+  splitInfo             :: Maybe (String,Int),++  -- paths etc.+  objectDir             :: Maybe String,+  dylibInstallName      :: Maybe String,+  hiDir                 :: Maybe String,+  hieDir                :: Maybe String,+  stubDir               :: Maybe String,+  dumpDir               :: Maybe String,++  objectSuf             :: String,+  hcSuf                 :: String,+  hiSuf                 :: String,+  hieSuf                :: String,++  canGenerateDynamicToo :: IORef Bool,+  dynObjectSuf          :: String,+  dynHiSuf              :: String,++  outputFile            :: Maybe String,+  dynOutputFile         :: Maybe String,+  outputHi              :: Maybe String,+  dynLibLoader          :: DynLibLoader,++  -- | This is set by 'GHC.Driver.Pipeline.runPipeline' based on where+  --    its output is going.+  dumpPrefix            :: Maybe FilePath,++  -- | Override the 'dumpPrefix' set by 'GHC.Driver.Pipeline.runPipeline'.+  --    Set by @-ddump-file-prefix@+  dumpPrefixForce       :: Maybe FilePath,++  ldInputs              :: [Option],++  includePaths          :: IncludeSpecs,+  libraryPaths          :: [String],+  frameworkPaths        :: [String],    -- used on darwin only+  cmdlineFrameworks     :: [String],    -- ditto++  rtsOpts               :: Maybe String,+  rtsOptsEnabled        :: RtsOptsEnabled,+  rtsOptsSuggestions    :: Bool,++  hpcDir                :: String,      -- ^ Path to store the .mix files++  -- Plugins+  pluginModNames        :: [ModuleName],+  pluginModNameOpts     :: [(ModuleName,String)],+  frontendPluginOpts    :: [String],+    -- ^ the @-ffrontend-opt@ flags given on the command line, in *reverse*+    -- order that they're specified on the command line.+  cachedPlugins         :: [LoadedPlugin],+    -- ^ plugins dynamically loaded after processing arguments. What will be+    -- loaded here is directed by pluginModNames. Arguments are loaded from+    -- pluginModNameOpts. The purpose of this field is to cache the plugins so+    -- they don't have to be loaded each time they are needed.  See+    -- 'GHC.Runtime.Loader.initializePlugins'.+  staticPlugins            :: [StaticPlugin],+    -- ^ static plugins which do not need dynamic loading. These plugins are+    -- intended to be added by GHC API users directly to this list.+    --+    -- To add dynamically loaded plugins through the GHC API see+    -- 'addPluginModuleName' instead.++  -- GHC API hooks+  hooks                 :: Hooks,++  --  For ghc -M+  depMakefile           :: FilePath,+  depIncludePkgDeps     :: Bool,+  depIncludeCppDeps     :: Bool,+  depExcludeMods        :: [ModuleName],+  depSuffixes           :: [String],++  --  Package flags+  packageDBFlags        :: [PackageDBFlag],+        -- ^ The @-package-db@ flags given on the command line, In+        -- *reverse* order that they're specified on the command line.+        -- This is intended to be applied with the list of "initial"+        -- package databases derived from @GHC_PACKAGE_PATH@; see+        -- 'getPackageConfRefs'.++  ignorePackageFlags    :: [IgnorePackageFlag],+        -- ^ The @-ignore-package@ flags from the command line.+        -- In *reverse* order that they're specified on the command line.+  packageFlags          :: [PackageFlag],+        -- ^ The @-package@ and @-hide-package@ flags from the command-line.+        -- In *reverse* order that they're specified on the command line.+  pluginPackageFlags    :: [PackageFlag],+        -- ^ The @-plugin-package-id@ flags from command line.+        -- In *reverse* order that they're specified on the command line.+  trustFlags            :: [TrustFlag],+        -- ^ The @-trust@ and @-distrust@ flags.+        -- In *reverse* order that they're specified on the command line.+  packageEnv            :: Maybe FilePath,+        -- ^ Filepath to the package environment file (if overriding default)++  pkgDatabase           :: Maybe [PackageDatabase],+        -- ^ Stack of package databases for the target platform.+        --+        -- A "package database" is a misleading name as it is really a Unit+        -- database (cf Note [The identifier lexicon]).+        --+        -- This field is populated by `initPackages`.+        --+        -- 'Nothing' means the databases have never been read from disk. If+        -- `initPackages` is called again, it doesn't reload the databases from+        -- disk.++  pkgState              :: PackageState,+        -- ^ Consolidated unit database built by 'initPackages' from the package+        -- databases in 'pkgDatabase' and flags ('-ignore-package', etc.).+        --+        -- It also contains mapping from module names to actual Modules.++  -- Temporary files+  -- These have to be IORefs, because the defaultCleanupHandler needs to+  -- know what to clean when an exception happens+  filesToClean          :: IORef FilesToClean,+  dirsToClean           :: IORef (Map FilePath FilePath),+  -- The next available suffix to uniquely name a temp file, updated atomically+  nextTempSuffix        :: IORef Int,++  -- Names of files which were generated from -ddump-to-file; used to+  -- track which ones we need to truncate because it's our first run+  -- through+  generatedDumps        :: IORef (Set FilePath),++  -- hsc dynamic flags+  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+  safeHaskell           :: SafeHaskellMode,+  safeInfer             :: Bool,+  safeInferred          :: Bool,+  -- We store the location of where some extension and flags were turned on so+  -- we can produce accurate error messages when Safe Haskell fails due to+  -- them.+  thOnLoc               :: SrcSpan,+  newDerivOnLoc         :: SrcSpan,+  overlapInstLoc        :: SrcSpan,+  incoherentOnLoc       :: SrcSpan,+  pkgTrustOnLoc         :: SrcSpan,+  warnSafeOnLoc         :: SrcSpan,+  warnUnsafeOnLoc       :: SrcSpan,+  trustworthyOnLoc      :: SrcSpan,+  -- Don't change this without updating extensionFlags:+  -- Here we collect the settings of the language extensions+  -- from the command line, the ghci config file and+  -- from interactive :set / :seti commands.+  extensions            :: [OnOff LangExt.Extension],+  -- extensionFlags should always be equal to+  --     flattenExtensionFlags language extensions+  -- LangExt.Extension is defined in libraries/ghc-boot so that it can be used+  -- by template-haskell+  extensionFlags        :: EnumSet LangExt.Extension,++  -- Unfolding control+  -- See Note [Discounts and thresholds] in GHC.Core.Unfold+  ufCreationThreshold   :: Int,+  ufUseThreshold        :: Int,+  ufFunAppDiscount      :: Int,+  ufDictDiscount        :: Int,+  ufKeenessFactor       :: Float,+  ufDearOp              :: Int,+  ufVeryAggressive      :: Bool,++  maxWorkerArgs         :: Int,++  ghciHistSize          :: Int,++  -- | MsgDoc output action: use "ErrUtils" instead of this if you can+  log_action            :: LogAction,+  dump_action           :: DumpAction,+  trace_action          :: TraceAction,+  flushOut              :: FlushOut,+  flushErr              :: FlushErr,++  ghcVersionFile        :: Maybe FilePath,+  haddockOptions        :: Maybe String,++  -- | GHCi scripts specified by -ghci-script, in reverse order+  ghciScripts           :: [String],++  -- Output style options+  pprUserLength         :: Int,+  pprCols               :: Int,++  useUnicode            :: Bool,+  useColor              :: OverridingBool,+  canUseColor           :: Bool,+  colScheme             :: Col.Scheme,++  -- | what kind of {-# SCC #-} to add automatically+  profAuto              :: ProfAuto,++  interactivePrint      :: Maybe String,++  nextWrapperNum        :: IORef (ModuleEnv Int),++  -- | Machine dependent flags (-m<blah> stuff)+  sseVersion            :: Maybe SseVersion,+  bmiVersion            :: Maybe BmiVersion,+  avx                   :: Bool,+  avx2                  :: Bool,+  avx512cd              :: Bool, -- Enable AVX-512 Conflict Detection Instructions.+  avx512er              :: Bool, -- Enable AVX-512 Exponential and Reciprocal Instructions.+  avx512f               :: Bool, -- Enable AVX-512 instructions.+  avx512pf              :: Bool, -- Enable AVX-512 PreFetch Instructions.++  -- | Run-time linker information (what options we need, etc.)+  rtldInfo              :: IORef (Maybe LinkerInfo),++  -- | Run-time compiler information+  rtccInfo              :: IORef (Maybe CompilerInfo),++  -- Constants used to control the amount of optimization done.++  -- | Max size, in bytes, of inline array allocations.+  maxInlineAllocSize    :: Int,++  -- | Only inline memcpy if it generates no more than this many+  -- pseudo (roughly: Cmm) instructions.+  maxInlineMemcpyInsns  :: Int,++  -- | Only inline memset if it generates no more than this many+  -- pseudo (roughly: Cmm) instructions.+  maxInlineMemsetInsns  :: Int,++  -- | Reverse the order of error messages in GHC/GHCi+  reverseErrors         :: Bool,++  -- | Limit the maximum number of errors to show+  maxErrors             :: Maybe Int,++  -- | Unique supply configuration for testing build determinism+  initialUnique         :: Int,+  uniqueIncrement       :: Int,++  -- | Temporary: CFG Edge weights for fast iterations+  cfgWeightInfo         :: CfgWeights+}++-- | Edge weights to use when generating a CFG from CMM+data CfgWeights+    = CFGWeights+    { uncondWeight :: Int+    , condBranchWeight :: Int+    , switchWeight :: Int+    , callWeight :: Int+    , likelyCondWeight :: Int+    , unlikelyCondWeight :: Int+    , infoTablePenalty :: Int+    , backEdgeBonus :: Int+    }++defaultCfgWeights :: CfgWeights+defaultCfgWeights+    = CFGWeights+    { uncondWeight = 1000+    , condBranchWeight = 800+    , switchWeight = 1+    , callWeight = -10+    , likelyCondWeight = 900+    , unlikelyCondWeight = 300+    , infoTablePenalty = 300+    , backEdgeBonus = 400+    }++parseCfgWeights :: String -> CfgWeights -> CfgWeights+parseCfgWeights s oldWeights =+        foldl' (\cfg (n,v) -> update n v cfg) oldWeights assignments+    where+        assignments = map assignment $ settings s+        update "uncondWeight" n w =+            w {uncondWeight = n}+        update "condBranchWeight" n w =+            w {condBranchWeight = n}+        update "switchWeight" n w =+            w {switchWeight = n}+        update "callWeight" n w =+            w {callWeight = n}+        update "likelyCondWeight" n w =+            w {likelyCondWeight = n}+        update "unlikelyCondWeight" n w =+            w {unlikelyCondWeight = n}+        update "infoTablePenalty" n w =+            w {infoTablePenalty = n}+        update "backEdgeBonus" n w =+            w {backEdgeBonus = n}+        update other _ _+            = panic $ other +++                      " is not a cfg weight parameter. " +++                      exampleString+        settings s+            | (s1,rest) <- break (== ',') s+            , null rest+            = [s1]+            | (s1,rest) <- break (== ',') s+            = s1 : settings (drop 1 rest)++        assignment as+            | (name, _:val) <- break (== '=') as+            = (name,read val)+            | otherwise+            = panic $ "Invalid cfg parameters." ++ exampleString++        exampleString = "Example parameters: uncondWeight=1000," +++            "condBranchWeight=800,switchWeight=0,callWeight=300" +++            ",likelyCondWeight=900,unlikelyCondWeight=300" +++            ",infoTablePenalty=300,backEdgeBonus=400"++backendMaintainsCfg :: DynFlags -> Bool+backendMaintainsCfg dflags = case (platformArch $ targetPlatform dflags) of+    -- ArchX86 -- Should work but not tested so disabled currently.+    ArchX86_64 -> True+    _otherwise -> False++class HasDynFlags m where+    getDynFlags :: m DynFlags++{- It would be desirable to have the more generalised++  instance (MonadTrans t, Monad m, HasDynFlags m) => HasDynFlags (t m) where+      getDynFlags = lift getDynFlags++instance definition. However, that definition would overlap with the+`HasDynFlags (GhcT m)` instance. Instead we define instances for a+couple of common Monad transformers explicitly. -}++instance (Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) where+    getDynFlags = lift getDynFlags++instance (Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m) where+    getDynFlags = lift getDynFlags++instance (Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) where+    getDynFlags = lift getDynFlags++instance (Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) where+    getDynFlags = lift getDynFlags++class ContainsDynFlags t where+    extractDynFlags :: t -> DynFlags++data ProfAuto+  = NoProfAuto         -- ^ no SCC annotations added+  | ProfAutoAll        -- ^ top-level and nested functions are annotated+  | ProfAutoTop        -- ^ top-level functions annotated only+  | ProfAutoExports    -- ^ exported functions annotated only+  | ProfAutoCalls      -- ^ annotate call-sites+  deriving (Eq,Enum)++data LlvmTarget = LlvmTarget+  { lDataLayout :: String+  , lCPU        :: String+  , lAttributes :: [String]+  }++-- | See Note [LLVM Configuration] in SysTools.+data LlvmConfig = LlvmConfig { llvmTargets :: [(String, LlvmTarget)]+                             , llvmPasses  :: [(Int, String)]+                             }++-----------------------------------------------------------------------------+-- Accessessors from 'DynFlags'++-- | "unbuild" a 'Settings' from a 'DynFlags'. This shouldn't be needed in the+-- vast majority of code. But GHCi questionably uses this to produce a default+-- 'DynFlags' from which to compute a flags diff for printing.+settings :: DynFlags -> Settings+settings dflags = Settings+  { sGhcNameVersion = ghcNameVersion dflags+  , sFileSettings = fileSettings dflags+  , sTargetPlatform = targetPlatform dflags+  , sToolSettings = toolSettings dflags+  , sPlatformMisc = platformMisc dflags+  , sPlatformConstants = platformConstants dflags+  , sRawSettings = rawSettings dflags+  }++programName :: DynFlags -> String+programName dflags = ghcNameVersion_programName $ ghcNameVersion dflags+projectVersion :: DynFlags -> String+projectVersion dflags = ghcNameVersion_projectVersion (ghcNameVersion dflags)+ghcUsagePath          :: DynFlags -> FilePath+ghcUsagePath dflags = fileSettings_ghcUsagePath $ fileSettings dflags+ghciUsagePath         :: DynFlags -> FilePath+ghciUsagePath dflags = fileSettings_ghciUsagePath $ fileSettings dflags+toolDir               :: DynFlags -> Maybe FilePath+toolDir dflags = fileSettings_toolDir $ fileSettings dflags+topDir                :: DynFlags -> FilePath+topDir dflags = fileSettings_topDir $ fileSettings dflags+tmpDir                :: DynFlags -> String+tmpDir dflags = fileSettings_tmpDir $ fileSettings dflags+extraGccViaCFlags     :: DynFlags -> [String]+extraGccViaCFlags dflags = toolSettings_extraGccViaCFlags $ toolSettings dflags+globalPackageDatabasePath   :: DynFlags -> FilePath+globalPackageDatabasePath dflags = fileSettings_globalPackageDatabase $ fileSettings dflags+pgm_L                 :: DynFlags -> String+pgm_L dflags = toolSettings_pgm_L $ toolSettings dflags+pgm_P                 :: DynFlags -> (String,[Option])+pgm_P dflags = toolSettings_pgm_P $ toolSettings dflags+pgm_F                 :: DynFlags -> String+pgm_F dflags = toolSettings_pgm_F $ toolSettings dflags+pgm_c                 :: DynFlags -> String+pgm_c dflags = toolSettings_pgm_c $ toolSettings dflags+pgm_a                 :: DynFlags -> (String,[Option])+pgm_a dflags = toolSettings_pgm_a $ toolSettings dflags+pgm_l                 :: DynFlags -> (String,[Option])+pgm_l dflags = toolSettings_pgm_l $ toolSettings dflags+pgm_dll               :: DynFlags -> (String,[Option])+pgm_dll dflags = toolSettings_pgm_dll $ toolSettings dflags+pgm_T                 :: DynFlags -> String+pgm_T dflags = toolSettings_pgm_T $ toolSettings dflags+pgm_windres           :: DynFlags -> String+pgm_windres dflags = toolSettings_pgm_windres $ toolSettings dflags+pgm_libtool           :: DynFlags -> String+pgm_libtool dflags = toolSettings_pgm_libtool $ toolSettings dflags+pgm_lcc               :: DynFlags -> (String,[Option])+pgm_lcc dflags = toolSettings_pgm_lcc $ toolSettings dflags+pgm_ar                :: DynFlags -> String+pgm_ar dflags = toolSettings_pgm_ar $ toolSettings dflags+pgm_ranlib            :: DynFlags -> String+pgm_ranlib dflags = toolSettings_pgm_ranlib $ toolSettings dflags+pgm_lo                :: DynFlags -> (String,[Option])+pgm_lo dflags = toolSettings_pgm_lo $ toolSettings dflags+pgm_lc                :: DynFlags -> (String,[Option])+pgm_lc dflags = toolSettings_pgm_lc $ toolSettings dflags+pgm_i                 :: DynFlags -> String+pgm_i dflags = toolSettings_pgm_i $ toolSettings dflags+opt_L                 :: DynFlags -> [String]+opt_L dflags = toolSettings_opt_L $ toolSettings dflags+opt_P                 :: DynFlags -> [String]+opt_P dflags = concatMap (wayOptP (targetPlatform dflags)) (ways dflags)+            ++ toolSettings_opt_P (toolSettings dflags)++-- This function packages everything that's needed to fingerprint opt_P+-- flags. See Note [Repeated -optP hashing].+opt_P_signature       :: DynFlags -> ([String], Fingerprint)+opt_P_signature dflags =+  ( concatMap (wayOptP (targetPlatform dflags)) (ways dflags)+  , toolSettings_opt_P_fingerprint $ toolSettings dflags+  )++opt_F                 :: DynFlags -> [String]+opt_F dflags= toolSettings_opt_F $ toolSettings dflags+opt_c                 :: DynFlags -> [String]+opt_c dflags = concatMap (wayOptc (targetPlatform dflags)) (ways dflags)+            ++ toolSettings_opt_c (toolSettings dflags)+opt_cxx               :: DynFlags -> [String]+opt_cxx dflags= toolSettings_opt_cxx $ toolSettings dflags+opt_a                 :: DynFlags -> [String]+opt_a dflags= toolSettings_opt_a $ toolSettings dflags+opt_l                 :: DynFlags -> [String]+opt_l dflags = concatMap (wayOptl (targetPlatform dflags)) (ways dflags)+            ++ toolSettings_opt_l (toolSettings dflags)+opt_windres           :: DynFlags -> [String]+opt_windres dflags= toolSettings_opt_windres $ toolSettings dflags+opt_lcc                :: DynFlags -> [String]+opt_lcc dflags= toolSettings_opt_lcc $ toolSettings dflags+opt_lo                :: DynFlags -> [String]+opt_lo dflags= toolSettings_opt_lo $ toolSettings dflags+opt_lc                :: DynFlags -> [String]+opt_lc dflags= toolSettings_opt_lc $ toolSettings dflags+opt_i                 :: DynFlags -> [String]+opt_i dflags= toolSettings_opt_i $ toolSettings dflags++tablesNextToCode :: DynFlags -> Bool+tablesNextToCode = platformMisc_tablesNextToCode . platformMisc++-- | The directory for this version of ghc in the user's app directory+-- (typically something like @~/.ghc/x86_64-linux-7.6.3@)+--+versionedAppDir :: DynFlags -> MaybeT IO FilePath+versionedAppDir dflags = do+  -- Make sure we handle the case the HOME isn't set (see #11678)+  appdir <- tryMaybeT $ getAppUserDataDirectory (programName dflags)+  return $ appdir </> versionedFilePath dflags++versionedFilePath :: DynFlags -> FilePath+versionedFilePath dflags = uniqueSubdir $ platformMini $ targetPlatform dflags++-- | The target code type of the compilation (if any).+--+-- Whenever you change the target, also make sure to set 'ghcLink' to+-- something sensible.+--+-- 'HscNothing' can be used to avoid generating any output, however, note+-- that:+--+--  * 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.+  | HscAsm         -- ^ Generate assembly using the native code generator.+  | HscLlvm        -- ^ Generate assembly using the llvm code generator.+  | HscInterpreted -- ^ Generate bytecode.  (Requires 'LinkInMemory')+  | HscNothing     -- ^ Don't generate any code.  See notes above.+  deriving (Eq, Show)++-- | Will this target result in an object file on the disk?+isObjectTarget :: HscTarget -> Bool+isObjectTarget HscC     = True+isObjectTarget HscAsm   = True+isObjectTarget HscLlvm  = True+isObjectTarget _        = False++-- | Does this target retain *all* top-level bindings for a module,+-- rather than just the exported bindings, in the TypeEnv and compiled+-- code (if any)?  In interpreted mode we do this, so that GHCi can+-- call functions inside a module.  In HscNothing mode we also do it,+-- so that Haddock can get access to the GlobalRdrEnv for a module+-- after typechecking it.+targetRetainsAllBindings :: HscTarget -> Bool+targetRetainsAllBindings HscInterpreted = True+targetRetainsAllBindings HscNothing     = True+targetRetainsAllBindings _              = False++-- | The 'GhcMode' tells us whether we're doing multi-module+-- compilation (controlled via the "GHC" API) or one-shot+-- (single-module) compilation.  This makes a difference primarily to+-- the "Finder": in one-shot mode we look for interface files for+-- imported modules, but in multi-module mode we look for source files+-- in order to check whether they need to be recompiled.+data GhcMode+  = CompManager         -- ^ @\-\-make@, GHCi, etc.+  | OneShot             -- ^ @ghc -c Foo.hs@+  | MkDepend            -- ^ @ghc -M@, see "Finder" for why we need this+  deriving Eq++instance Outputable GhcMode where+  ppr CompManager = text "CompManager"+  ppr OneShot     = text "OneShot"+  ppr MkDepend    = text "MkDepend"++isOneShot :: GhcMode -> Bool+isOneShot OneShot = True+isOneShot _other  = False++-- | What to do in the link step, if there is one.+data GhcLink+  = NoLink              -- ^ Don't link at all+  | LinkBinary          -- ^ Link object code into a binary+  | LinkInMemory        -- ^ Use the in-memory dynamic linker (works for both+                        --   bytecode and object code).+  | LinkDynLib          -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)+  | LinkStaticLib       -- ^ Link objects into a static lib+  deriving (Eq, Show)++isNoLink :: GhcLink -> Bool+isNoLink NoLink = True+isNoLink _      = False++-- | We accept flags which make packages visible, but how they select+-- the package varies; this data type reflects what selection criterion+-- is used.+data PackageArg =+      PackageArg String    -- ^ @-package@, by 'PackageName'+    | UnitIdArg UnitId     -- ^ @-package-id@, by 'UnitId'+  deriving (Eq, Show)+instance Outputable PackageArg where+    ppr (PackageArg pn) = text "package" <+> text pn+    ppr (UnitIdArg uid) = text "unit" <+> ppr uid++-- | Represents the renaming that may be associated with an exposed+-- package, e.g. the @rns@ part of @-package "foo (rns)"@.+--+-- Here are some example parsings of the package flags (where+-- a string literal is punned to be a 'ModuleName':+--+--      * @-package foo@ is @ModRenaming True []@+--      * @-package foo ()@ is @ModRenaming False []@+--      * @-package foo (A)@ is @ModRenaming False [("A", "A")]@+--      * @-package foo (A as B)@ is @ModRenaming False [("A", "B")]@+--      * @-package foo with (A as B)@ is @ModRenaming True [("A", "B")]@+data ModRenaming = ModRenaming {+    modRenamingWithImplicit :: Bool, -- ^ Bring all exposed modules into scope?+    modRenamings :: [(ModuleName, ModuleName)] -- ^ Bring module @m@ into scope+                                               --   under name @n@.+  } deriving (Eq)+instance Outputable ModRenaming where+    ppr (ModRenaming b rns) = ppr b <+> parens (ppr rns)++-- | Flags for manipulating the set of non-broken packages.+newtype IgnorePackageFlag = IgnorePackage String -- ^ @-ignore-package@+  deriving (Eq)++-- | Flags for manipulating package trust.+data TrustFlag+  = TrustPackage    String -- ^ @-trust@+  | DistrustPackage String -- ^ @-distrust@+  deriving (Eq)++-- | Flags for manipulating packages visibility.+data PackageFlag+  = ExposePackage   String PackageArg ModRenaming -- ^ @-package@, @-package-id@+  | HidePackage     String -- ^ @-hide-package@+  deriving (Eq) -- NB: equality instance is used by packageFlagsChanged++data PackageDBFlag+  = PackageDB PkgDbRef+  | NoUserPackageDB+  | NoGlobalPackageDB+  | ClearPackageDBs+  deriving (Eq)++packageFlagsChanged :: DynFlags -> DynFlags -> Bool+packageFlagsChanged idflags1 idflags0 =+  packageFlags idflags1 /= packageFlags idflags0 ||+  ignorePackageFlags idflags1 /= ignorePackageFlags idflags0 ||+  pluginPackageFlags idflags1 /= pluginPackageFlags idflags0 ||+  trustFlags idflags1 /= trustFlags idflags0 ||+  packageDBFlags idflags1 /= packageDBFlags idflags0 ||+  packageGFlags idflags1 /= packageGFlags idflags0+ where+   packageGFlags dflags = map (`gopt` dflags)+     [ Opt_HideAllPackages+     , Opt_HideAllPluginPackages+     , Opt_AutoLinkPackages ]++instance Outputable PackageFlag where+    ppr (ExposePackage n arg rn) = text n <> braces (ppr arg <+> ppr rn)+    ppr (HidePackage str) = text "-hide-package" <+> text str++-- | The 'HscTarget' value corresponding to the default way to create+-- object files on the current platform.++defaultHscTarget :: Platform -> PlatformMisc -> HscTarget+defaultHscTarget platform pMisc+  | platformUnregisterised platform = HscC+  | platformMisc_ghcWithNativeCodeGen pMisc = HscAsm+  | otherwise = HscLlvm++defaultObjectTarget :: DynFlags -> HscTarget+defaultObjectTarget dflags = defaultHscTarget+  (targetPlatform dflags)+  (platformMisc dflags)++data DynLibLoader+  = Deployable+  | SystemDependent+  deriving Eq++data RtsOptsEnabled+  = RtsOptsNone | RtsOptsIgnore | RtsOptsIgnoreAll | RtsOptsSafeOnly+  | RtsOptsAll+  deriving (Show)++-- | Are we building with @-fPIE@ or @-fPIC@ enabled?+positionIndependent :: DynFlags -> Bool+positionIndependent dflags = gopt Opt_PIC dflags || gopt Opt_PIE dflags++-----------------------------------------------------------------------------+-- Ways++-- The central concept of a "way" is that all objects in a given+-- program must be compiled in the same "way".  Certain options change+-- parameters of the virtual machine, eg. profiling adds an extra word+-- to the object header, so profiling objects cannot be linked with+-- non-profiling objects.++-- After parsing the command-line options, we determine which "way" we+-- are building - this might be a combination way, eg. profiling+threaded.++-- We then find the "build-tag" associated with this way, and this+-- becomes the suffix used to find .hi files and libraries used in+-- this compilation.++data Way+  = WayCustom String -- for GHC API clients building custom variants+  | WayThreaded+  | WayDebug+  | WayProf+  | WayEventLog+  | WayDyn+  deriving (Eq, Ord, Show)++allowed_combination :: [Way] -> Bool+allowed_combination way = and [ x `allowedWith` y+                              | x <- way, y <- way, x < y ]+  where+        -- Note ordering in these tests: the left argument is+        -- <= the right argument, according to the Ord instance+        -- on Way above.++        -- dyn is allowed with everything+        _ `allowedWith` WayDyn                  = True+        WayDyn `allowedWith` _                  = True++        -- debug is allowed with everything+        _ `allowedWith` WayDebug                = True+        WayDebug `allowedWith` _                = True++        (WayCustom {}) `allowedWith` _          = True+        WayThreaded `allowedWith` WayProf       = True+        WayThreaded `allowedWith` WayEventLog   = True+        WayProf     `allowedWith` WayEventLog   = True+        _ `allowedWith` _                       = False++mkBuildTag :: [Way] -> String+mkBuildTag ways = concat (intersperse "_" (map wayTag ways))++wayTag :: Way -> String+wayTag (WayCustom xs) = xs+wayTag WayThreaded = "thr"+wayTag WayDebug    = "debug"+wayTag WayDyn      = "dyn"+wayTag WayProf     = "p"+wayTag WayEventLog = "l"++wayRTSOnly :: Way -> Bool+wayRTSOnly (WayCustom {}) = False+wayRTSOnly WayThreaded = True+wayRTSOnly WayDebug    = True+wayRTSOnly WayDyn      = False+wayRTSOnly WayProf     = False+wayRTSOnly WayEventLog = True++wayDesc :: Way -> String+wayDesc (WayCustom xs) = xs+wayDesc WayThreaded = "Threaded"+wayDesc WayDebug    = "Debug"+wayDesc WayDyn      = "Dynamic"+wayDesc WayProf     = "Profiling"+wayDesc WayEventLog = "RTS Event Logging"++-- Turn these flags on when enabling this way+wayGeneralFlags :: Platform -> Way -> [GeneralFlag]+wayGeneralFlags _ (WayCustom {}) = []+wayGeneralFlags _ WayThreaded = []+wayGeneralFlags _ WayDebug    = []+wayGeneralFlags _ WayDyn      = [Opt_PIC, Opt_ExternalDynamicRefs]+    -- We could get away without adding -fPIC when compiling the+    -- modules of a program that is to be linked with -dynamic; the+    -- program itself does not need to be position-independent, only+    -- the libraries need to be.  HOWEVER, GHCi links objects into a+    -- .so before loading the .so using the system linker.  Since only+    -- PIC objects can be linked into a .so, we have to compile even+    -- modules of the main program with -fPIC when using -dynamic.+wayGeneralFlags _ WayProf     = [Opt_SccProfilingOn]+wayGeneralFlags _ WayEventLog = []++-- Turn these flags off when enabling this way+wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]+wayUnsetGeneralFlags _ (WayCustom {}) = []+wayUnsetGeneralFlags _ WayThreaded = []+wayUnsetGeneralFlags _ WayDebug    = []+wayUnsetGeneralFlags _ WayDyn      = [-- There's no point splitting+                                      -- when we're going to be dynamically+                                      -- linking. Plus it breaks compilation+                                      -- on OSX x86.+                                      Opt_SplitSections]+wayUnsetGeneralFlags _ WayProf     = []+wayUnsetGeneralFlags _ WayEventLog = []++wayOptc :: Platform -> Way -> [String]+wayOptc _ (WayCustom {}) = []+wayOptc platform WayThreaded = case platformOS platform of+                               OSOpenBSD -> ["-pthread"]+                               OSNetBSD  -> ["-pthread"]+                               _         -> []+wayOptc _ WayDebug      = []+wayOptc _ WayDyn        = []+wayOptc _ WayProf       = ["-DPROFILING"]+wayOptc _ WayEventLog   = ["-DTRACING"]++wayOptl :: Platform -> Way -> [String]+wayOptl _ (WayCustom {}) = []+wayOptl platform WayThreaded =+        case platformOS platform of+        -- N.B. FreeBSD cc throws a warning if we pass -pthread without+        -- actually using any pthread symbols.+        OSFreeBSD  -> ["-pthread", "-Wno-unused-command-line-argument"]+        OSOpenBSD  -> ["-pthread"]+        OSNetBSD   -> ["-pthread"]+        _          -> []+wayOptl _ WayDebug      = []+wayOptl _ WayDyn        = []+wayOptl _ WayProf       = []+wayOptl _ WayEventLog   = []++wayOptP :: Platform -> Way -> [String]+wayOptP _ (WayCustom {}) = []+wayOptP _ WayThreaded = []+wayOptP _ WayDebug    = []+wayOptP _ WayDyn      = []+wayOptP _ WayProf     = ["-DPROFILING"]+wayOptP _ WayEventLog = ["-DTRACING"]++whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()+whenGeneratingDynamicToo dflags f = ifGeneratingDynamicToo dflags f (return ())++ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a+ifGeneratingDynamicToo dflags f g = generateDynamicTooConditional dflags f g g++whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()+whenCannotGenerateDynamicToo dflags f+    = ifCannotGenerateDynamicToo dflags f (return ())++ifCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a+ifCannotGenerateDynamicToo dflags f g+    = generateDynamicTooConditional dflags g f g++generateDynamicTooConditional :: MonadIO m+                              => DynFlags -> m a -> m a -> m a -> m a+generateDynamicTooConditional dflags canGen cannotGen notTryingToGen+    = if gopt Opt_BuildDynamicToo dflags+      then do let ref = canGenerateDynamicToo dflags+              b <- liftIO $ readIORef ref+              if b then canGen else cannotGen+      else notTryingToGen++dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags+dynamicTooMkDynamicDynFlags dflags0+    = let dflags1 = addWay' WayDyn dflags0+          dflags2 = dflags1 {+                        outputFile = dynOutputFile dflags1,+                        hiSuf = dynHiSuf dflags1,+                        objectSuf = dynObjectSuf dflags1+                    }+          dflags3 = updateWays dflags2+          dflags4 = gopt_unset dflags3 Opt_BuildDynamicToo+      in dflags4++-- | Compute the path of the dynamic object corresponding to an object file.+dynamicOutputFile :: DynFlags -> FilePath -> FilePath+dynamicOutputFile dflags outputFile = dynOut outputFile+  where+    dynOut = flip addExtension (dynObjectSuf dflags) . dropExtension++-----------------------------------------------------------------------------++-- | Used by 'GHC.runGhc' to partially initialize a new 'DynFlags' value+initDynFlags :: DynFlags -> IO DynFlags+initDynFlags dflags = do+ let -- We can't build with dynamic-too on Windows, as labels before+     -- the fork point are different depending on whether we are+     -- building dynamically or not.+     platformCanGenerateDynamicToo+         = platformOS (targetPlatform dflags) /= OSMinGW32+ refCanGenerateDynamicToo <- newIORef platformCanGenerateDynamicToo+ refNextTempSuffix <- newIORef 0+ refFilesToClean <- newIORef emptyFilesToClean+ refDirsToClean <- newIORef Map.empty+ refGeneratedDumps <- newIORef Set.empty+ refRtldInfo <- newIORef Nothing+ refRtccInfo <- newIORef Nothing+ wrapperNum <- newIORef emptyModuleEnv+ canUseUnicode <- do let enc = localeEncoding+                         str = "‘’"+                     (withCString enc str $ \cstr ->+                          do str' <- peekCString enc cstr+                             return (str == str'))+                         `catchIOError` \_ -> return False+ ghcNoUnicodeEnv <- lookupEnv "GHC_NO_UNICODE"+ let useUnicode' = isNothing ghcNoUnicodeEnv && canUseUnicode+ canUseColor <- stderrSupportsAnsiColors+ maybeGhcColorsEnv  <- lookupEnv "GHC_COLORS"+ maybeGhcColoursEnv <- lookupEnv "GHC_COLOURS"+ let adjustCols (Just env) = Col.parseScheme env+     adjustCols Nothing    = id+ let (useColor', colScheme') =+       (adjustCols maybeGhcColoursEnv . adjustCols maybeGhcColorsEnv)+       (useColor dflags, colScheme dflags)+ return dflags{+        canGenerateDynamicToo = refCanGenerateDynamicToo,+        nextTempSuffix = refNextTempSuffix,+        filesToClean   = refFilesToClean,+        dirsToClean    = refDirsToClean,+        generatedDumps = refGeneratedDumps,+        nextWrapperNum = wrapperNum,+        useUnicode    = useUnicode',+        useColor      = useColor',+        canUseColor   = canUseColor,+        colScheme     = colScheme',+        rtldInfo      = refRtldInfo,+        rtccInfo      = refRtccInfo+        }++-- | 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 -> LlvmConfig -> DynFlags+defaultDynFlags mySettings llvmConfig =+-- See Note [Updating flag description in the User's Guide]+     DynFlags {+        ghcMode                 = CompManager,+        ghcLink                 = LinkBinary,+        hscTarget               = defaultHscTarget (sTargetPlatform mySettings) (sPlatformMisc mySettings),+        integerLibrary          = sIntegerLibraryType mySettings,+        verbosity               = 0,+        optLevel                = 0,+        debugLevel              = 0,+        simplPhases             = 2,+        maxSimplIterations      = 4,+        ruleCheck               = Nothing,+        inlineCheck             = Nothing,+        binBlobThreshold        = 500000, -- 500K is a good default (see #16190)+        maxRelevantBinds        = Just 6,+        maxValidHoleFits   = Just 6,+        maxRefHoleFits     = Just 6,+        refLevelHoleFits   = Nothing,+        maxUncoveredPatterns    = 4,+        maxPmCheckModels        = 30,+        simplTickFactor         = 100,+        specConstrThreshold     = Just 2000,+        specConstrCount         = Just 3,+        specConstrRecursive     = 3,+        liberateCaseThreshold   = Just 2000,+        floatLamArgs            = Just 0, -- Default: float only if no fvs+        liftLamsRecArgs         = Just 5, -- Default: the number of available argument hardware registers on x86_64+        liftLamsNonRecArgs      = Just 5, -- Default: the number of available argument hardware registers on x86_64+        liftLamsKnown           = False,  -- Default: don't turn known calls into unknown ones+        cmmProcAlignment        = Nothing,++        historySize             = 20,+        strictnessBefore        = [],++        parMakeCount            = Just 1,++        enableTimeStats         = False,+        ghcHeapSize             = Nothing,++        importPaths             = ["."],+        mainModIs               = mAIN,+        mainFunIs               = Nothing,+        reductionDepth          = treatZeroAsInf mAX_REDUCTION_DEPTH,+        solverIterations        = treatZeroAsInf mAX_SOLVER_ITERATIONS,++        thisInstalledUnitId     = toInstalledUnitId mainUnitId,+        thisUnitIdInsts_        = Nothing,+        thisComponentId_        = Nothing,++        objectDir               = Nothing,+        dylibInstallName        = Nothing,+        hiDir                   = Nothing,+        hieDir                  = Nothing,+        stubDir                 = Nothing,+        dumpDir                 = Nothing,++        objectSuf               = phaseInputExt StopLn,+        hcSuf                   = phaseInputExt HCc,+        hiSuf                   = "hi",+        hieSuf                  = "hie",++        canGenerateDynamicToo   = panic "defaultDynFlags: No canGenerateDynamicToo",+        dynObjectSuf            = "dyn_" ++ phaseInputExt StopLn,+        dynHiSuf                = "dyn_hi",++        pluginModNames          = [],+        pluginModNameOpts       = [],+        frontendPluginOpts      = [],+        cachedPlugins           = [],+        staticPlugins           = [],+        hooks                   = emptyHooks,++        outputFile              = Nothing,+        dynOutputFile           = Nothing,+        outputHi                = Nothing,+        dynLibLoader            = SystemDependent,+        dumpPrefix              = Nothing,+        dumpPrefixForce         = Nothing,+        ldInputs                = [],+        includePaths            = IncludeSpecs [] [],+        libraryPaths            = [],+        frameworkPaths          = [],+        cmdlineFrameworks       = [],+        rtsOpts                 = Nothing,+        rtsOptsEnabled          = RtsOptsSafeOnly,+        rtsOptsSuggestions      = True,++        hpcDir                  = ".hpc",++        packageDBFlags          = [],+        packageFlags            = [],+        pluginPackageFlags      = [],+        ignorePackageFlags      = [],+        trustFlags              = [],+        packageEnv              = Nothing,+        pkgDatabase             = Nothing,+        pkgState                = emptyPackageState,+        ways                    = defaultWays mySettings,+        buildTag                = mkBuildTag (defaultWays mySettings),+        splitInfo               = Nothing,++        ghcNameVersion = sGhcNameVersion mySettings,+        fileSettings = sFileSettings mySettings,+        toolSettings = sToolSettings mySettings,+        targetPlatform = sTargetPlatform mySettings,+        platformMisc = sPlatformMisc mySettings,+        platformConstants = sPlatformConstants mySettings,+        rawSettings = sRawSettings mySettings,++        -- See Note [LLVM configuration].+        llvmConfig              = llvmConfig,++        -- ghc -M values+        depMakefile       = "Makefile",+        depIncludePkgDeps = False,+        depIncludeCppDeps = False,+        depExcludeMods    = [],+        depSuffixes       = [],+        -- end of ghc -M values+        nextTempSuffix = panic "defaultDynFlags: No nextTempSuffix",+        filesToClean   = panic "defaultDynFlags: No filesToClean",+        dirsToClean    = panic "defaultDynFlags: No dirsToClean",+        generatedDumps = panic "defaultDynFlags: No generatedDumps",+        ghcVersionFile = Nothing,+        haddockOptions = Nothing,+        dumpFlags = EnumSet.empty,+        generalFlags = EnumSet.fromList (defaultFlags mySettings),+        warningFlags = EnumSet.fromList standardWarnings,+        fatalWarningFlags = EnumSet.empty,+        ghciScripts = [],+        language = Nothing,+        safeHaskell = Sf_None,+        safeInfer   = True,+        safeInferred = True,+        thOnLoc = noSrcSpan,+        newDerivOnLoc = noSrcSpan,+        overlapInstLoc = noSrcSpan,+        incoherentOnLoc = noSrcSpan,+        pkgTrustOnLoc = noSrcSpan,+        warnSafeOnLoc = noSrcSpan,+        warnUnsafeOnLoc = noSrcSpan,+        trustworthyOnLoc = noSrcSpan,+        extensions = [],+        extensionFlags = flattenExtensionFlags Nothing [],++        -- The ufCreationThreshold threshold must be reasonably high to+        -- take account of possible discounts.+        -- E.g. 450 is not enough in 'fulsom' for Interval.sqr to inline+        -- into Csg.calc (The unfolding for sqr never makes it into the+        -- interface file.)+        ufCreationThreshold = 750,+        ufUseThreshold      = 60,+        ufFunAppDiscount    = 60,+        -- Be fairly keen to inline a function if that means+        -- we'll be able to pick the right method from a dictionary+        ufDictDiscount      = 30,+        ufKeenessFactor     = 1.5,+        ufDearOp            = 40,+        ufVeryAggressive    = False,++        maxWorkerArgs = 10,++        ghciHistSize = 50, -- keep a log of length 50 by default++        -- Logging++        log_action   = defaultLogAction,+        dump_action  = defaultDumpAction,+        trace_action = defaultTraceAction,++        flushOut = defaultFlushOut,+        flushErr = defaultFlushErr,+        pprUserLength = 5,+        pprCols = 100,+        useUnicode = False,+        useColor = Auto,+        canUseColor = False,+        colScheme = Col.defaultScheme,+        profAuto = NoProfAuto,+        interactivePrint = Nothing,+        nextWrapperNum = panic "defaultDynFlags: No nextWrapperNum",+        sseVersion = Nothing,+        bmiVersion = Nothing,+        avx = False,+        avx2 = False,+        avx512cd = False,+        avx512er = False,+        avx512f = False,+        avx512pf = False,+        rtldInfo = panic "defaultDynFlags: no rtldInfo",+        rtccInfo = panic "defaultDynFlags: no rtccInfo",++        maxInlineAllocSize = 128,+        maxInlineMemcpyInsns = 32,+        maxInlineMemsetInsns = 32,++        initialUnique = 0,+        uniqueIncrement = 1,++        reverseErrors = False,+        maxErrors     = Nothing,+        cfgWeightInfo = defaultCfgWeights+      }++defaultWays :: Settings -> [Way]+defaultWays settings = if pc_DYNAMIC_BY_DEFAULT (sPlatformConstants settings)+                       then [WayDyn]+                       else []++interpWays :: [Way]+interpWays+  | dynamicGhc = [WayDyn]+  | rtsIsProfiled = [WayProf]+  | otherwise = []++interpreterProfiled :: DynFlags -> Bool+interpreterProfiled dflags+  | gopt Opt_ExternalInterpreter dflags = gopt Opt_SccProfilingOn dflags+  | otherwise = rtsIsProfiled++interpreterDynamic :: DynFlags -> Bool+interpreterDynamic dflags+  | gopt Opt_ExternalInterpreter dflags = WayDyn `elem` ways dflags+  | otherwise = dynamicGhc++--------------------------------------------------------------------------+--+-- Note [JSON Error Messages]+--+-- When the user requests the compiler output to be dumped as json+-- we used to collect them all in an IORef and then print them at the end.+-- This doesn't work very well with GHCi. (See #14078) So instead we now+-- use the simpler method of just outputting a JSON document inplace to+-- stdout.+--+-- Before the compiler calls log_action, it has already turned the `ErrMsg`+-- into a formatted message. This means that we lose some possible+-- information to provide to the user but refactoring log_action is quite+-- invasive as it is called in many places. So, for now I left it alone+-- and we can refine its behaviour as users request different output.++type FatalMessager = String -> IO ()++type LogAction = DynFlags+              -> WarnReason+              -> Severity+              -> SrcSpan+              -> PprStyle+              -> MsgDoc+              -> IO ()++defaultFatalMessager :: FatalMessager+defaultFatalMessager = hPutStrLn stderr+++-- See Note [JSON Error Messages]+--+jsonLogAction :: LogAction+jsonLogAction dflags reason severity srcSpan _style msg+  = do+    defaultLogActionHPutStrDoc dflags stdout (doc $$ text "")+                               (mkCodeStyle CStyle)+    where+      doc = renderJSON $+              JSObject [ ( "span", json srcSpan )+                       , ( "doc" , JSString (showSDoc dflags msg) )+                       , ( "severity", json severity )+                       , ( "reason" ,   json reason )+                       ]+++defaultLogAction :: LogAction+defaultLogAction dflags reason severity srcSpan style msg+    = case severity of+      SevOutput      -> printOut msg style+      SevDump        -> printOut (msg $$ blankLine) style+      SevInteractive -> putStrSDoc msg style+      SevInfo        -> printErrs msg style+      SevFatal       -> printErrs msg style+      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++      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+ = defaultLogActionHPutStrDoc dflags h (d $$ text "") sty++defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()+defaultLogActionHPutStrDoc dflags h d sty+  -- Don't add a newline at the end, so that successive+  -- calls to this log-action can output all on the same line+  = printSDoc Pretty.PageMode dflags h sty d++newtype FlushOut = FlushOut (IO ())++defaultFlushOut :: FlushOut+defaultFlushOut = FlushOut $ hFlush stdout++newtype FlushErr = FlushErr (IO ())++defaultFlushErr :: FlushErr+defaultFlushErr = FlushErr $ hFlush stderr++{-+Note [Verbosity levels]+~~~~~~~~~~~~~~~~~~~~~~~+    0   |   print errors & warnings only+    1   |   minimal verbosity: print "compiling M ... done." for each module.+    2   |   equivalent to -dshow-passes+    3   |   equivalent to existing "ghc -v"+    4   |   "ghc -v -ddump-most"+    5   |   "ghc -v -ddump-all"+-}++data OnOff a = On a+             | Off a+  deriving (Eq, Show)++instance Outputable a => Outputable (OnOff a) where+  ppr (On x)  = text "On" <+> ppr x+  ppr (Off x) = text "Off" <+> ppr x++-- OnOffs accumulate in reverse order, so we use foldr in order to+-- process them in the right order+flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> EnumSet LangExt.Extension+flattenExtensionFlags ml = foldr f defaultExtensionFlags+    where f (On f)  flags = EnumSet.insert f flags+          f (Off f) flags = EnumSet.delete f flags+          defaultExtensionFlags = EnumSet.fromList (languageExtensions ml)++-- | The language extensions implied by the various language variants.+-- When updating this be sure to update the flag documentation in+-- @docs/users-guide/glasgow_exts.rst@.+languageExtensions :: Maybe Language -> [LangExt.Extension]++languageExtensions Nothing+    -- Nothing => the default case+    = LangExt.NondecreasingIndentation -- This has been on by default for some time+    : delete LangExt.DatatypeContexts  -- The Haskell' committee decided to+                                       -- remove datatype contexts from the+                                       -- language:+   -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html+      (languageExtensions (Just Haskell2010))++   -- NB: MonoPatBinds is no longer the default++languageExtensions (Just Haskell98)+    = [LangExt.ImplicitPrelude,+       -- See Note [When is StarIsType enabled]+       LangExt.StarIsType,+       LangExt.CUSKs,+       LangExt.MonomorphismRestriction,+       LangExt.NPlusKPatterns,+       LangExt.DatatypeContexts,+       LangExt.TraditionalRecordSyntax,+       LangExt.NondecreasingIndentation+           -- strictly speaking non-standard, but we always had this+           -- on implicitly before the option was added in 7.1, and+           -- turning it off breaks code, so we're keeping it on for+           -- backwards compatibility.  Cabal uses -XHaskell98 by+           -- default unless you specify another language.+      ]++languageExtensions (Just Haskell2010)+    = [LangExt.ImplicitPrelude,+       -- See Note [When is StarIsType enabled]+       LangExt.StarIsType,+       LangExt.CUSKs,+       LangExt.MonomorphismRestriction,+       LangExt.DatatypeContexts,+       LangExt.TraditionalRecordSyntax,+       LangExt.EmptyDataDecls,+       LangExt.ForeignFunctionInterface,+       LangExt.PatternGuards,+       LangExt.DoAndIfThenElse,+       LangExt.RelaxedPolyRec]++hasPprDebug :: DynFlags -> Bool+hasPprDebug = dopt Opt_D_ppr_debug++hasNoDebugOutput :: DynFlags -> Bool+hasNoDebugOutput = dopt Opt_D_no_debug_output++hasNoStateHack :: DynFlags -> Bool+hasNoStateHack = gopt Opt_G_NoStateHack++hasNoOptCoercion :: DynFlags -> Bool+hasNoOptCoercion = gopt Opt_G_NoOptCoercion+++-- | Test whether a 'DumpFlag' is set+dopt :: DumpFlag -> DynFlags -> Bool+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+          enableIfVerbose Opt_D_dump_cs_trace               = False+          enableIfVerbose Opt_D_dump_if_trace               = False+          enableIfVerbose Opt_D_dump_vt_trace               = False+          enableIfVerbose Opt_D_dump_tc                     = False+          enableIfVerbose Opt_D_dump_rn                     = False+          enableIfVerbose Opt_D_dump_rn_stats               = False+          enableIfVerbose Opt_D_dump_hi_diffs               = False+          enableIfVerbose Opt_D_verbose_core2core           = False+          enableIfVerbose Opt_D_verbose_stg2stg             = False+          enableIfVerbose Opt_D_dump_splices                = False+          enableIfVerbose Opt_D_th_dec_file                 = False+          enableIfVerbose Opt_D_dump_rule_firings           = False+          enableIfVerbose Opt_D_dump_rule_rewrites          = False+          enableIfVerbose Opt_D_dump_simpl_trace            = False+          enableIfVerbose Opt_D_dump_rtti                   = False+          enableIfVerbose Opt_D_dump_inlinings              = False+          enableIfVerbose Opt_D_dump_core_stats             = False+          enableIfVerbose Opt_D_dump_asm_stats              = False+          enableIfVerbose Opt_D_dump_types                  = False+          enableIfVerbose Opt_D_dump_simpl_iterations       = False+          enableIfVerbose Opt_D_dump_ticked                 = False+          enableIfVerbose Opt_D_dump_view_pattern_commoning = False+          enableIfVerbose Opt_D_dump_mod_cycles             = False+          enableIfVerbose Opt_D_dump_mod_map                = False+          enableIfVerbose Opt_D_dump_ec_trace               = False+          enableIfVerbose _                                 = True++-- | Set a 'DumpFlag'+dopt_set :: DynFlags -> DumpFlag -> DynFlags+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 = EnumSet.delete f (dumpFlags dfs) }++-- | Test whether a 'GeneralFlag' is set+gopt :: GeneralFlag -> DynFlags -> Bool+gopt f dflags  = f `EnumSet.member` generalFlags dflags++-- | Set a 'GeneralFlag'+gopt_set :: DynFlags -> GeneralFlag -> DynFlags+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 = EnumSet.delete f (generalFlags dfs) }++-- | Test whether a 'WarningFlag' is set+wopt :: WarningFlag -> DynFlags -> Bool+wopt f dflags  = f `EnumSet.member` warningFlags dflags++-- | Set a 'WarningFlag'+wopt_set :: DynFlags -> WarningFlag -> DynFlags+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 = EnumSet.delete f (warningFlags dfs) }++-- | Test whether a 'WarningFlag' is set as fatal+wopt_fatal :: WarningFlag -> DynFlags -> Bool+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 = EnumSet.insert f (fatalWarningFlags dfs) }++-- | Mark a 'WarningFlag' as not fatal+wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags+wopt_unset_fatal dfs f+    = dfs { fatalWarningFlags = EnumSet.delete f (fatalWarningFlags dfs) }++-- | Test whether a 'LangExt.Extension' is set+xopt :: LangExt.Extension -> DynFlags -> Bool+xopt f dflags = f `EnumSet.member` extensionFlags dflags++-- | Set a 'LangExt.Extension'+xopt_set :: DynFlags -> LangExt.Extension -> DynFlags+xopt_set dfs f+    = let onoffs = On f : extensions dfs+      in dfs { extensions = onoffs,+               extensionFlags = flattenExtensionFlags (language dfs) onoffs }++-- | Unset a 'LangExt.Extension'+xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags+xopt_unset dfs f+    = let onoffs = Off f : extensions dfs+      in dfs { extensions = onoffs,+               extensionFlags = flattenExtensionFlags (language dfs) onoffs }++-- | Set or unset a 'LangExt.Extension', unless it has been explicitly+--   set or unset before.+xopt_set_unlessExplSpec+        :: LangExt.Extension+        -> (DynFlags -> LangExt.Extension -> DynFlags)+        -> DynFlags -> DynFlags+xopt_set_unlessExplSpec ext setUnset dflags =+    let referedExts = stripOnOff <$> extensions dflags+        stripOnOff (On x)  = x+        stripOnOff (Off x) = x+    in+        if ext `elem` referedExts then dflags else setUnset dflags ext++lang_set :: DynFlags -> Maybe Language -> DynFlags+lang_set dflags lang =+   dflags {+            language = lang,+            extensionFlags = flattenExtensionFlags lang (extensions dflags)+          }++-- | Set the Haskell language standard to use+setLanguage :: Language -> DynP ()+setLanguage l = upd (`lang_set` Just l)++-- | Some modules have dependencies on others through the DynFlags rather than textual imports+dynFlagDependencies :: DynFlags -> [ModuleName]+dynFlagDependencies = pluginModNames++-- | Is the -fpackage-trust mode on+packageTrustOn :: DynFlags -> Bool+packageTrustOn = gopt Opt_PackageTrust++-- | Is Safe Haskell on in some way (including inference mode)+safeHaskellOn :: DynFlags -> Bool+safeHaskellOn dflags = safeHaskellModeEnabled dflags || safeInferOn dflags++safeHaskellModeEnabled :: DynFlags -> Bool+safeHaskellModeEnabled dflags = safeHaskell dflags `elem` [Sf_Unsafe, Sf_Trustworthy+                                                   , Sf_Safe ]+++-- | Is the Safe Haskell safe language in use+safeLanguageOn :: DynFlags -> Bool+safeLanguageOn dflags = safeHaskell dflags == Sf_Safe++-- | Is the Safe Haskell safe inference mode active+safeInferOn :: DynFlags -> Bool+safeInferOn = safeInfer++-- | Test if Safe Imports are on in some form+safeImportsOn :: DynFlags -> Bool+safeImportsOn dflags = safeHaskell dflags == Sf_Unsafe ||+                       safeHaskell dflags == Sf_Trustworthy ||+                       safeHaskell dflags == Sf_Safe++-- | Set a 'Safe Haskell' flag+setSafeHaskell :: SafeHaskellMode -> DynP ()+setSafeHaskell s = updM f+    where f dfs = do+              let sf = safeHaskell dfs+              safeM <- combineSafeFlags sf s+              case s of+                Sf_Safe -> return $ dfs { safeHaskell = safeM, safeInfer = False }+                -- leave safe inferrence on in Trustworthy mode so we can warn+                -- if it could have been inferred safe.+                Sf_Trustworthy -> do+                  l <- getCurLoc+                  return $ dfs { safeHaskell = safeM, trustworthyOnLoc = l }+                -- leave safe inference on in Unsafe mode as well.+                _ -> return $ dfs { safeHaskell = safeM }++-- | Are all direct imports required to be safe for this Safe Haskell mode?+-- Direct imports are when the code explicitly imports a module+safeDirectImpsReq :: DynFlags -> Bool+safeDirectImpsReq d = safeLanguageOn d++-- | Are all implicit imports required to be safe for this Safe Haskell mode?+-- Implicit imports are things in the prelude. e.g System.IO when print is used.+safeImplicitImpsReq :: DynFlags -> Bool+safeImplicitImpsReq d = safeLanguageOn d++-- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.+-- This makes Safe Haskell very much a monoid but for now I prefer this as I don't+-- want to export this functionality from the module but do want to export the+-- type constructors.+combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode+combineSafeFlags a b | a == Sf_None         = return b+                     | b == Sf_None         = return a+                     | a == Sf_Ignore || b == Sf_Ignore = return Sf_Ignore+                     | a == b               = return a+                     | otherwise            = addErr errm >> pure a+    where errm = "Incompatible Safe Haskell flags! ("+                    ++ show a ++ ", " ++ show b ++ ")"++-- | A list of unsafe flags under Safe Haskell. Tuple elements are:+--     * name of the flag+--     * function to get srcspan that enabled the flag+--     * function to test if the flag is on+--     * function to turn the flag off+unsafeFlags, unsafeFlagsForInfer+  :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]+unsafeFlags = [ ("-XGeneralizedNewtypeDeriving", newDerivOnLoc,+                    xopt LangExt.GeneralizedNewtypeDeriving,+                    flip xopt_unset LangExt.GeneralizedNewtypeDeriving)+              , ("-XTemplateHaskell", thOnLoc,+                    xopt LangExt.TemplateHaskell,+                    flip xopt_unset LangExt.TemplateHaskell)+              ]+unsafeFlagsForInfer = unsafeFlags+++-- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order+getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from+        -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors+        -> [a]                  -- ^ Correctly ordered extracted options+getOpts dflags opts = reverse (opts dflags)+        -- We add to the options from the front, so we need to reverse the list++-- | Gets the verbosity flag for the current verbosity level. This is fed to+-- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included+getVerbFlags :: DynFlags -> [String]+getVerbFlags dflags+  | verbosity dflags >= 4 = ["-v"]+  | otherwise             = []++setObjectDir, setHiDir, setHieDir, setStubDir, setDumpDir, setOutputDir,+         setDynObjectSuf, setDynHiSuf,+         setDylibInstallName,+         setObjectSuf, setHiSuf, setHieSuf, setHcSuf, parseDynLibLoaderMode,+         setPgmP, addOptl, addOptc, addOptcxx, addOptP,+         addCmdlineFramework, addHaddockOpts, addGhciScript,+         setInteractivePrint+   :: String -> DynFlags -> DynFlags+setOutputFile, setDynOutputFile, setOutputHi, setDumpPrefixForce+   :: Maybe String -> DynFlags -> DynFlags++setObjectDir  f d = d { objectDir  = Just f}+setHiDir      f d = d { hiDir      = Just f}+setHieDir     f d = d { hieDir     = Just f}+setStubDir    f d = d { stubDir    = Just f+                      , includePaths = addGlobalInclude (includePaths d) [f] }+  -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file+  -- \#included from the .hc file when compiling via C (i.e. unregisterised+  -- builds).+setDumpDir    f d = d { dumpDir    = Just f}+setOutputDir  f = setObjectDir f+                . setHieDir f+                . setHiDir f+                . setStubDir f+                . setDumpDir f+setDylibInstallName  f d = d { dylibInstallName = Just f}++setObjectSuf    f d = d { objectSuf    = f}+setDynObjectSuf f d = d { dynObjectSuf = f}+setHiSuf        f d = d { hiSuf        = f}+setHieSuf       f d = d { hieSuf       = f}+setDynHiSuf     f d = d { dynHiSuf     = f}+setHcSuf        f d = d { hcSuf        = f}++setOutputFile f d = d { outputFile = f}+setDynOutputFile f d = d { dynOutputFile = f}+setOutputHi   f d = d { outputHi   = f}++setJsonLogAction :: DynFlags -> DynFlags+setJsonLogAction d = d { log_action = jsonLogAction }++thisComponentId :: DynFlags -> ComponentId+thisComponentId dflags =+  case thisComponentId_ dflags of+    Just cid -> cid+    Nothing  ->+      case thisUnitIdInsts_ dflags of+        Just _  ->+          throwGhcException $ CmdLineError ("Use of -instantiated-with requires -this-component-id")+        Nothing -> ComponentId (unitIdFS (thisPackage dflags))++thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]+thisUnitIdInsts dflags =+    case thisUnitIdInsts_ dflags of+        Just insts -> insts+        Nothing    -> []++thisPackage :: DynFlags -> UnitId+thisPackage dflags =+    case thisUnitIdInsts_ dflags of+        Nothing -> default_uid+        Just insts+          | all (\(x,y) -> mkHoleModule x == y) insts+          -> newUnitId (thisComponentId dflags) insts+          | otherwise+          -> default_uid+  where+    default_uid = DefiniteUnitId (DefUnitId (thisInstalledUnitId dflags))++parseUnitIdInsts :: String -> [(ModuleName, Module)]+parseUnitIdInsts str = case filter ((=="").snd) (readP_to_S parse str) of+    [(r, "")] -> r+    _ -> throwGhcException $ CmdLineError ("Can't parse -instantiated-with: " ++ str)+  where parse = sepBy parseEntry (R.char ',')+        parseEntry = do+            n <- parseModuleName+            _ <- R.char '='+            m <- parseModuleId+            return (n, m)++setUnitIdInsts :: String -> DynFlags -> DynFlags+setUnitIdInsts s d =+    d { thisUnitIdInsts_ = Just (parseUnitIdInsts s) }++setComponentId :: String -> DynFlags -> DynFlags+setComponentId s d =+    d { thisComponentId_ = Just (ComponentId (fsLit s)) }++addPluginModuleName :: String -> DynFlags -> DynFlags+addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }++clearPluginModuleNames :: DynFlags -> DynFlags+clearPluginModuleNames d =+    d { pluginModNames = []+      , pluginModNameOpts = []+      , cachedPlugins = [] }++addPluginModuleNameOption :: String -> DynFlags -> DynFlags+addPluginModuleNameOption optflag d = d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }+  where (m, rest) = break (== ':') optflag+        option = case rest of+          [] -> "" -- should probably signal an error+          (_:plug_opt) -> plug_opt -- ignore the ':' from break++addFrontendPluginOption :: String -> DynFlags -> DynFlags+addFrontendPluginOption s d = d { frontendPluginOpts = s : frontendPluginOpts d }++parseDynLibLoaderMode f d =+ case splitAt 8 f of+   ("deploy", "")       -> d { dynLibLoader = Deployable }+   ("sysdep", "")       -> d { dynLibLoader = SystemDependent }+   _                    -> throwGhcException (CmdLineError ("Unknown dynlib loader: " ++ f))++setDumpPrefixForce f d = d { dumpPrefixForce = f}++-- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]+-- Config.hs should really use Option.+setPgmP   f = alterToolSettings (\s -> s { toolSettings_pgm_P   = (pgm, map Option args)})+  where (pgm:args) = words f+addOptl   f = alterToolSettings (\s -> s { toolSettings_opt_l   = f : toolSettings_opt_l s})+addOptc   f = alterToolSettings (\s -> s { toolSettings_opt_c   = f : toolSettings_opt_c s})+addOptcxx f = alterToolSettings (\s -> s { toolSettings_opt_cxx = f : toolSettings_opt_cxx s})+addOptP   f = alterToolSettings $ \s -> s+          { toolSettings_opt_P   = f : toolSettings_opt_P s+          , toolSettings_opt_P_fingerprint = fingerprintStrings (f : toolSettings_opt_P s)+          }+          -- See Note [Repeated -optP hashing]+  where+  fingerprintStrings ss = fingerprintFingerprints $ map fingerprintString ss+++setDepMakefile :: FilePath -> DynFlags -> DynFlags+setDepMakefile f d = d { depMakefile = f }++setDepIncludeCppDeps :: Bool -> DynFlags -> DynFlags+setDepIncludeCppDeps b d = d { depIncludeCppDeps = b }++setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags+setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }++addDepExcludeMod :: String -> DynFlags -> DynFlags+addDepExcludeMod m d+    = d { depExcludeMods = mkModuleName m : depExcludeMods d }++addDepSuffix :: FilePath -> DynFlags -> DynFlags+addDepSuffix s d = d { depSuffixes = s : depSuffixes d }++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}++setInteractivePrint f d = d { interactivePrint = Just f}++-----------------------------------------------------------------------------+-- Setting the optimisation level++updOptLevel :: Int -> DynFlags -> DynFlags+-- ^ Sets the 'DynFlags' to be appropriate to the optimisation level+updOptLevel n dfs+  = dfs2{ optLevel = final_n }+  where+   final_n = max 0 (min 2 n)    -- Clamp to 0 <= n <= 2+   dfs1 = foldr (flip gopt_unset) dfs  remove_gopts+   dfs2 = foldr (flip gopt_set)   dfs1 extra_gopts++   extra_gopts  = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]+   remove_gopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]++{- **********************************************************************+%*                                                                      *+                DynFlags parser+%*                                                                      *+%********************************************************************* -}++-- -----------------------------------------------------------------------------+-- Parsing the dynamic flags.+++-- | Parse dynamic flags from a list of command line arguments.  Returns+-- the parsed 'DynFlags', the left-over arguments, and a list of warnings.+-- 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], [Warn])+                            -- ^ Updated 'DynFlags', left-over arguments, and+                            -- list of warnings.+parseDynamicFlagsCmdLine = parseDynamicFlagsFull flagsAll True+++-- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags+-- (-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], [Warn])+                          -- ^ Updated 'DynFlags', left-over arguments, and+                          -- list of warnings.+parseDynamicFilePragma = parseDynamicFlagsFull flagsDynamic False+++-- | Parses the dynamically set flags for GHC. This is the most general form of+-- the dynamic flag parser that the other methods simply wrap. It allows+-- saying which flags are valid flags and indicating if we are parsing+-- arguments from the command line or from a file pragma.+parseDynamicFlagsFull :: MonadIO m+                  => [Flag (CmdLineP DynFlags)]    -- ^ valid flags to match against+                  -> Bool                          -- ^ are the arguments from the command line?+                  -> DynFlags                      -- ^ current dynamic flags+                  -> [Located String]              -- ^ arguments to parse+                  -> 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) . errMsg) $ errs++  -- check for disabled flags in safe haskell+  let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1+      dflags3 = updateWays dflags2+      theWays = ways dflags3++  unless (allowed_combination theWays) $ liftIO $+      throwGhcExceptionIO (CmdLineError ("combination not supported: " +++                               intercalate "/" (map wayDesc theWays)))++  let chooseOutput+        | isJust (outputFile dflags3)          -- Only iff user specified -o ...+        , not (isJust (dynOutputFile dflags3)) -- but not -dyno+        = return $ dflags3 { dynOutputFile = Just $ dynamicOutputFile dflags3 outFile }+        | otherwise+        = return dflags3+        where+          outFile = fromJust $ outputFile dflags3+  dflags4 <- ifGeneratingDynamicToo dflags3 chooseOutput (return dflags3)++  let (dflags5, consistency_warnings) = makeDynFlagsConsistent dflags4++  -- Set timer stats & heap size+  when (enableTimeStats dflags5) $ liftIO enableTimingStats+  case (ghcHeapSize dflags5) of+    Just x -> liftIO (setHeapSize x)+    _      -> return ()++  liftIO $ setUnsafeGlobalDynFlags dflags5++  let warns' = map (Warn Cmd.NoReason) (consistency_warnings ++ sh_warns)++  return (dflags5, leftover, warns' ++ warns)++-- | Write an error or warning to the 'LogOutput'.+putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle+          -> MsgDoc -> IO ()+putLogMsg dflags = log_action dflags dflags++updateWays :: DynFlags -> DynFlags+updateWays dflags+    = let theWays = sort $ nub $ ways dflags+      in dflags {+             ways        = theWays,+             buildTag    = mkBuildTag (filter (not . wayRTSOnly) theWays)+         }++-- | Check (and potentially disable) any extensions that aren't allowed+-- in safe mode.+--+-- The bool is to indicate if we are parsing command line flags (false means+-- file pragma). This allows us to generate better warnings.+safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])+safeFlagCheck _ dflags | safeLanguageOn dflags = (dflagsUnset, warns)+  where+    -- Handle illegal flags under safe language.+    (dflagsUnset, warns) = foldl' check_method (dflags, []) unsafeFlags++    check_method (df, warns) (str,loc,test,fix)+        | test df   = (fix df, warns ++ safeFailure (loc df) str)+        | otherwise = (df, warns)++    safeFailure loc str+       = [L loc $ str ++ " is not allowed in Safe Haskell; ignoring "+           ++ str]++safeFlagCheck cmdl dflags =+  case (safeInferOn dflags) of+    True | safeFlags -> (dflags', warn)+    True             -> (dflags' { safeInferred = False }, warn)+    False            -> (dflags', warn)++  where+    -- dynflags and warn for when -fpackage-trust by itself with no safe+    -- haskell flag+    (dflags', warn)+      | not (safeHaskellModeEnabled dflags) && not cmdl && packageTrustOn dflags+      = (gopt_unset dflags Opt_PackageTrust, pkgWarnMsg)+      | otherwise = (dflags, [])++    pkgWarnMsg = [L (pkgTrustOnLoc dflags') $+                    "-fpackage-trust ignored;" +++                    " must be specified with a Safe Haskell flag"]++    -- Have we inferred Unsafe? See Note [GHC.Driver.Main . Safe Haskell Inference]+    safeFlags = all (\(_,_,t,_) -> not $ t dflags) unsafeFlagsForInfer+++{- **********************************************************************+%*                                                                      *+                DynFlags specifications+%*                                                                      *+%********************************************************************* -}++-- | All dynamic flags option strings without the deprecated ones.+-- These are the user facing strings for enabling and disabling options.+allNonDeprecatedFlags :: [String]+allNonDeprecatedFlags = allFlagsDeps False++-- | All flags with possibility to filter deprecated ones+allFlagsDeps :: Bool -> [String]+allFlagsDeps keepDeprecated = [ '-':flagName flag+                              | (deprecated, flag) <- flagsAllDeps+                              , keepDeprecated || not (isDeprecated deprecated)]+  where isDeprecated Deprecated = True+        isDeprecated _ = False++{-+ - Below we export user facing symbols for GHC dynamic flags for use with the+ - GHC API.+ -}++-- All dynamic flags present in GHC.+flagsAll :: [Flag (CmdLineP DynFlags)]+flagsAll = map snd flagsAllDeps++-- All dynamic flags present in GHC with deprecation information.+flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]+flagsAllDeps =  package_flags_deps ++ dynamic_flags_deps+++-- All dynamic flags, minus package flags, present in GHC.+flagsDynamic :: [Flag (CmdLineP DynFlags)]+flagsDynamic = map snd dynamic_flags_deps++-- ALl package flags present in GHC.+flagsPackage :: [Flag (CmdLineP DynFlags)]+flagsPackage = map snd package_flags_deps++----------------Helpers to make flags and keep deprecation information----------++type FlagMaker m = String -> OptKind m -> Flag m+type DynFlagMaker = FlagMaker (CmdLineP DynFlags)+data Deprecation = NotDeprecated | Deprecated deriving (Eq, Ord)++-- Make a non-deprecated flag+make_ord_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags)+              -> (Deprecation, Flag (CmdLineP DynFlags))+make_ord_flag fm name kind = (NotDeprecated, fm name kind)++-- Make a deprecated flag+make_dep_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags) -> String+                 -> (Deprecation, Flag (CmdLineP DynFlags))+make_dep_flag fm name kind message = (Deprecated,+                                      fm name $ add_dep_message kind message)++add_dep_message :: OptKind (CmdLineP DynFlags) -> String+                -> OptKind (CmdLineP DynFlags)+add_dep_message (NoArg f) message = NoArg $ f >> deprecate message+add_dep_message (HasArg f) message = HasArg $ \s -> f s >> deprecate message+add_dep_message (SepArg f) message = SepArg $ \s -> f s >> deprecate message+add_dep_message (Prefix f) message = Prefix $ \s -> f s >> deprecate message+add_dep_message (OptPrefix f) message =+                                  OptPrefix $ \s -> f s >> deprecate message+add_dep_message (OptIntSuffix f) message =+                               OptIntSuffix $ \oi -> f oi >> deprecate message+add_dep_message (IntSuffix f) message =+                                  IntSuffix $ \i -> f i >> deprecate message+add_dep_message (FloatSuffix f) message =+                                FloatSuffix $ \fl -> f fl >> deprecate message+add_dep_message (PassFlag f) message =+                                   PassFlag $ \s -> f s >> deprecate message+add_dep_message (AnySuffix f) message =+                                  AnySuffix $ \s -> f s >> deprecate message++----------------------- The main flags themselves ------------------------------+-- See Note [Updating flag description in the User's Guide]+-- See Note [Supporting CLI completion]+dynamic_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]+dynamic_flags_deps = [+    make_dep_flag defFlag "n" (NoArg $ return ())+        "The -n flag is deprecated and no longer has any effect"+  , make_ord_flag defFlag "cpp"      (NoArg (setExtensionFlag LangExt.Cpp))+  , make_ord_flag defFlag "F"        (NoArg (setGeneralFlag Opt_Pp))+  , (Deprecated, defFlag "#include"+      (HasArg (\_s ->+         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+        (\n -> case n of+                 Just n+                     | n > 0     -> upd (\d -> d { parMakeCount = Just n })+                     | otherwise -> addErr "Syntax: -j[n] where n > 0"+                 Nothing -> upd (\d -> d { parMakeCount = Nothing })))+                 -- When the number of parallel builds+                 -- is omitted, it is the same+                 -- as specifying that the number of+                 -- parallel builds is equal to the+                 -- result of getNumProcessors+  , make_ord_flag defFlag "instantiated-with"   (sepArg setUnitIdInsts)+  , make_ord_flag defFlag "this-component-id"   (sepArg setComponentId)++    -- RTS options -------------------------------------------------------------+  , make_ord_flag defFlag "H"           (HasArg (\s -> upd (\d ->+          d { ghcHeapSize = Just $ fromIntegral (decodeSize s)})))++  , make_ord_flag defFlag "Rghc-timing" (NoArg (upd (\d ->+                                               d { enableTimeStats = True })))++    ------- ways ---------------------------------------------------------------+  , make_ord_flag defGhcFlag "prof"           (NoArg (addWay WayProf))+  , make_ord_flag defGhcFlag "eventlog"       (NoArg (addWay WayEventLog))+  , make_ord_flag defGhcFlag "debug"          (NoArg (addWay WayDebug))+  , make_ord_flag defGhcFlag "threaded"       (NoArg (addWay WayThreaded))++  , make_ord_flag defGhcFlag "ticky"+      (NoArg (setGeneralFlag Opt_Ticky >> addWay WayDebug))++    -- -ticky enables ticky-ticky code generation, and also implies -debug which+    -- is required to get the RTS ticky support.++        ----- Linker --------------------------------------------------------+  , make_ord_flag defGhcFlag "static"         (NoArg removeWayDyn)+  , make_ord_flag defGhcFlag "dynamic"        (NoArg (addWay WayDyn))+  , make_ord_flag defGhcFlag "rdynamic" $ noArg $+#if defined(linux_HOST_OS)+                              addOptl "-rdynamic"+#elif defined(mingw32_HOST_OS)+                              addOptl "-Wl,--export-all-symbols"+#else+    -- ignored for compat w/ gcc:+                              id+#endif+  , make_ord_flag defGhcFlag "relative-dynlib-paths"+      (NoArg (setGeneralFlag Opt_RelativeDynlibPaths))+  , make_ord_flag defGhcFlag "copy-libs-when-linking"+      (NoArg (setGeneralFlag Opt_SingleLibFolder))+  , make_ord_flag defGhcFlag "pie"            (NoArg (setGeneralFlag Opt_PICExecutable))+  , make_ord_flag defGhcFlag "no-pie"         (NoArg (unSetGeneralFlag Opt_PICExecutable))++        ------- Specific phases  --------------------------------------------+    -- need to appear before -pgmL to be parsed as LLVM flags.+  , make_ord_flag defFlag "pgmlo"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_lo  = (f,[]) }+  , make_ord_flag defFlag "pgmlc"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_lc  = (f,[]) }+  , make_ord_flag defFlag "pgmi"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_i   =  f }+  , make_ord_flag defFlag "pgmL"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_L   = f }+  , make_ord_flag defFlag "pgmP"+      (hasArg setPgmP)+  , make_ord_flag defFlag "pgmF"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_F   = f }+  , make_ord_flag defFlag "pgmc"+      $ hasArg $ \f -> alterToolSettings $ \s -> s+         { toolSettings_pgm_c   = f+         , -- Don't pass -no-pie with -pgmc+           -- (see #15319)+           toolSettings_ccSupportsNoPie = False+         }+  , make_ord_flag defFlag "pgms"+      (HasArg (\_ -> addWarn "Object splitting was removed in GHC 8.8"))+  , make_ord_flag defFlag "pgma"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_a   = (f,[]) }+  , make_ord_flag defFlag "pgml"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_l   = (f,[]) }+  , make_ord_flag defFlag "pgmdll"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_dll = (f,[]) }+  , make_ord_flag defFlag "pgmwindres"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_windres = f }+  , make_ord_flag defFlag "pgmlibtool"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_libtool = f }+  , make_ord_flag defFlag "pgmar"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_ar = f }+  , make_ord_flag defFlag "pgmranlib"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_ranlib = f }+++    -- need to appear before -optl/-opta to be parsed as LLVM flags.+  , make_ord_flag defFlag "optlo"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_lo  = f : toolSettings_opt_lo s }+  , make_ord_flag defFlag "optlc"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_lc  = f : toolSettings_opt_lc s }+  , make_ord_flag defFlag "opti"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_i   = f : toolSettings_opt_i s }+  , make_ord_flag defFlag "optL"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_L   = f : toolSettings_opt_L s }+  , make_ord_flag defFlag "optP"+      (hasArg addOptP)+  , make_ord_flag defFlag "optF"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_F   = f : toolSettings_opt_F s }+  , make_ord_flag defFlag "optc"+      (hasArg addOptc)+  , make_ord_flag defFlag "optcxx"+      (hasArg addOptcxx)+  , make_ord_flag defFlag "opta"+      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_a   = f : toolSettings_opt_a s }+  , make_ord_flag defFlag "optl"+      (hasArg addOptl)+  , make_ord_flag defFlag "optwindres"+      $ hasArg $ \f ->+        alterToolSettings $ \s -> s { toolSettings_opt_windres = f : toolSettings_opt_windres s }++  , make_ord_flag defGhcFlag "split-objs"+      (NoArg $ addWarn "ignoring -split-objs")++  , make_ord_flag defGhcFlag "split-sections"+      (noArgM (\dflags -> do+        if platformHasSubsectionsViaSymbols (targetPlatform dflags)+          then do addWarn $+                    "-split-sections is not useful on this platform " +++                    "since it always uses subsections via symbols. Ignoring."+                  return dflags+          else return (gopt_set dflags Opt_SplitSections)))++        -------- ghc -M -----------------------------------------------------+  , make_ord_flag defGhcFlag "dep-suffix"              (hasArg addDepSuffix)+  , make_ord_flag defGhcFlag "dep-makefile"            (hasArg setDepMakefile)+  , make_ord_flag defGhcFlag "include-cpp-deps"+        (noArg (setDepIncludeCppDeps True))+  , make_ord_flag defGhcFlag "include-pkg-deps"+        (noArg (setDepIncludePkgDeps True))+  , make_ord_flag defGhcFlag "exclude-module"          (hasArg addDepExcludeMod)++        -------- Linking ----------------------------------------------------+  , make_ord_flag defGhcFlag "no-link"+        (noArg (\d -> d { ghcLink=NoLink }))+  , make_ord_flag defGhcFlag "shared"+        (noArg (\d -> d { ghcLink=LinkDynLib }))+  , make_ord_flag defGhcFlag "staticlib"+        (noArg (\d -> d { ghcLink=LinkStaticLib }))+  , make_ord_flag defGhcFlag "dynload"            (hasArg parseDynLibLoaderMode)+  , make_ord_flag defGhcFlag "dylib-install-name" (hasArg setDylibInstallName)++        ------- Libraries ---------------------------------------------------+  , make_ord_flag defFlag "L"   (Prefix addLibraryPath)+  , make_ord_flag defFlag "l"   (hasArg (addLdInputs . Option . ("-l" ++)))++        ------- Frameworks --------------------------------------------------+        -- -framework-path should really be -F ...+  , make_ord_flag defFlag "framework-path" (HasArg addFrameworkPath)+  , make_ord_flag defFlag "framework"      (hasArg addCmdlineFramework)++        ------- Output Redirection ------------------------------------------+  , make_ord_flag defGhcFlag "odir"              (hasArg setObjectDir)+  , make_ord_flag defGhcFlag "o"                 (sepArg (setOutputFile . Just))+  , make_ord_flag defGhcFlag "dyno"+        (sepArg (setDynOutputFile . Just))+  , make_ord_flag defGhcFlag "ohi"+        (hasArg (setOutputHi . Just ))+  , make_ord_flag defGhcFlag "osuf"              (hasArg setObjectSuf)+  , make_ord_flag defGhcFlag "dynosuf"           (hasArg setDynObjectSuf)+  , make_ord_flag defGhcFlag "hcsuf"             (hasArg setHcSuf)+  , make_ord_flag defGhcFlag "hisuf"             (hasArg setHiSuf)+  , make_ord_flag defGhcFlag "hiesuf"            (hasArg setHieSuf)+  , make_ord_flag defGhcFlag "dynhisuf"          (hasArg setDynHiSuf)+  , make_ord_flag defGhcFlag "hidir"             (hasArg setHiDir)+  , make_ord_flag defGhcFlag "hiedir"            (hasArg setHieDir)+  , make_ord_flag defGhcFlag "tmpdir"            (hasArg setTmpDir)+  , make_ord_flag defGhcFlag "stubdir"           (hasArg setStubDir)+  , make_ord_flag defGhcFlag "dumpdir"           (hasArg setDumpDir)+  , make_ord_flag defGhcFlag "outputdir"         (hasArg setOutputDir)+  , make_ord_flag defGhcFlag "ddump-file-prefix"+        (hasArg (setDumpPrefixForce . Just))++  , make_ord_flag defGhcFlag "dynamic-too"+        (NoArg (setGeneralFlag Opt_BuildDynamicToo))++        ------- Keeping temporary files -------------------------------------+     -- These can be singular (think ghc -c) or plural (think ghc --make)+  , make_ord_flag defGhcFlag "keep-hc-file"+        (NoArg (setGeneralFlag Opt_KeepHcFiles))+  , make_ord_flag defGhcFlag "keep-hc-files"+        (NoArg (setGeneralFlag Opt_KeepHcFiles))+  , make_ord_flag defGhcFlag "keep-hscpp-file"+        (NoArg (setGeneralFlag Opt_KeepHscppFiles))+  , make_ord_flag defGhcFlag "keep-hscpp-files"+        (NoArg (setGeneralFlag Opt_KeepHscppFiles))+  , make_ord_flag defGhcFlag "keep-s-file"+        (NoArg (setGeneralFlag Opt_KeepSFiles))+  , make_ord_flag defGhcFlag "keep-s-files"+        (NoArg (setGeneralFlag Opt_KeepSFiles))+  , make_ord_flag defGhcFlag "keep-llvm-file"+        (NoArg $ setObjTarget HscLlvm >> setGeneralFlag Opt_KeepLlvmFiles)+  , make_ord_flag defGhcFlag "keep-llvm-files"+        (NoArg $ setObjTarget HscLlvm >> setGeneralFlag Opt_KeepLlvmFiles)+     -- This only makes sense as plural+  , make_ord_flag defGhcFlag "keep-tmp-files"+        (NoArg (setGeneralFlag Opt_KeepTmpFiles))+  , make_ord_flag defGhcFlag "keep-hi-file"+        (NoArg (setGeneralFlag Opt_KeepHiFiles))+  , make_ord_flag defGhcFlag "no-keep-hi-file"+        (NoArg (unSetGeneralFlag Opt_KeepHiFiles))+  , make_ord_flag defGhcFlag "keep-hi-files"+        (NoArg (setGeneralFlag Opt_KeepHiFiles))+  , make_ord_flag defGhcFlag "no-keep-hi-files"+        (NoArg (unSetGeneralFlag Opt_KeepHiFiles))+  , make_ord_flag defGhcFlag "keep-o-file"+        (NoArg (setGeneralFlag Opt_KeepOFiles))+  , make_ord_flag defGhcFlag "no-keep-o-file"+        (NoArg (unSetGeneralFlag Opt_KeepOFiles))+  , make_ord_flag defGhcFlag "keep-o-files"+        (NoArg (setGeneralFlag Opt_KeepOFiles))+  , make_ord_flag defGhcFlag "no-keep-o-files"+        (NoArg (unSetGeneralFlag Opt_KeepOFiles))++        ------- Miscellaneous ----------------------------------------------+  , make_ord_flag defGhcFlag "no-auto-link-packages"+        (NoArg (unSetGeneralFlag Opt_AutoLinkPackages))+  , make_ord_flag defGhcFlag "no-hs-main"+        (NoArg (setGeneralFlag Opt_NoHsMain))+  , make_ord_flag defGhcFlag "fno-state-hack"+        (NoArg (setGeneralFlag Opt_G_NoStateHack))+  , make_ord_flag defGhcFlag "fno-opt-coercion"+        (NoArg (setGeneralFlag Opt_G_NoOptCoercion))+  , make_ord_flag defGhcFlag "with-rtsopts"+        (HasArg setRtsOpts)+  , make_ord_flag defGhcFlag "rtsopts"+        (NoArg (setRtsOptsEnabled RtsOptsAll))+  , make_ord_flag defGhcFlag "rtsopts=all"+        (NoArg (setRtsOptsEnabled RtsOptsAll))+  , make_ord_flag defGhcFlag "rtsopts=some"+        (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 "dhex-word-literals"+        (NoArg (setGeneralFlag Opt_HexWordLiterals))++  , 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)+  , make_ord_flag defGhcFlag "hpcdir"               (SepArg setOptHpcDir)+  , make_ord_flag defGhciFlag "ghci-script"         (hasArg addGhciScript)+  , make_ord_flag defGhciFlag "interactive-print"   (hasArg setInteractivePrint)+  , make_ord_flag defGhcFlag "ticky-allocd"+        (NoArg (setGeneralFlag Opt_Ticky_Allocd))+  , make_ord_flag defGhcFlag "ticky-LNE"+        (NoArg (setGeneralFlag Opt_Ticky_LNE))+  , make_ord_flag defGhcFlag "ticky-dyn-thunk"+        (NoArg (setGeneralFlag Opt_Ticky_Dyn_Thunk))+        ------- recompilation checker --------------------------------------+  , make_dep_flag defGhcFlag "recomp"+        (NoArg $ unSetGeneralFlag Opt_ForceRecomp)+             "Use -fno-force-recomp instead"+  , make_dep_flag defGhcFlag "no-recomp"+        (NoArg $ setGeneralFlag Opt_ForceRecomp) "Use -fforce-recomp instead"+  , make_ord_flag defFlag "fmax-errors"+      (intSuffix (\n d -> d { maxErrors = Just (max 1 n) }))+  , make_ord_flag defFlag "fno-max-errors"+      (noArg (\d -> d { maxErrors = Nothing }))+  , make_ord_flag defFlag "freverse-errors"+        (noArg (\d -> d {reverseErrors = True} ))+  , make_ord_flag defFlag "fno-reverse-errors"+        (noArg (\d -> d {reverseErrors = False} ))++        ------ HsCpp opts ---------------------------------------------------+  , make_ord_flag defFlag "D"              (AnySuffix (upd . addOptP))+  , make_ord_flag defFlag "U"              (AnySuffix (upd . addOptP))++        ------- Include/Import Paths ----------------------------------------+  , make_ord_flag defFlag "I"              (Prefix    addIncludePath)+  , make_ord_flag defFlag "i"              (OptPrefix addImportPath)++        ------ Output style options -----------------------------------------+  , make_ord_flag defFlag "dppr-user-length" (intSuffix (\n d ->+                                                       d { pprUserLength = n }))+  , make_ord_flag defFlag "dppr-cols"        (intSuffix (\n d ->+                                                             d { pprCols = n }))+  , make_ord_flag defFlag "fdiagnostics-color=auto"+      (NoArg (upd (\d -> d { useColor = Auto })))+  , make_ord_flag defFlag "fdiagnostics-color=always"+      (NoArg (upd (\d -> d { useColor = Always })))+  , make_ord_flag defFlag "fdiagnostics-color=never"+      (NoArg (upd (\d -> d { useColor = Never })))++  -- Suppress all that is suppressable in core dumps.+  -- Except for uniques, as some simplifier phases introduce new variables that+  -- have otherwise identical names.+  , make_ord_flag defGhcFlag "dsuppress-all"+      (NoArg $ do setGeneralFlag Opt_SuppressCoercions+                  setGeneralFlag Opt_SuppressVarKinds+                  setGeneralFlag Opt_SuppressModulePrefixes+                  setGeneralFlag Opt_SuppressTypeApplications+                  setGeneralFlag Opt_SuppressIdInfo+                  setGeneralFlag Opt_SuppressTicks+                  setGeneralFlag Opt_SuppressStgExts+                  setGeneralFlag Opt_SuppressTypeSignatures+                  setGeneralFlag Opt_SuppressTimestamps)++        ------ Debugging ----------------------------------------------------+  , make_ord_flag defGhcFlag "dstg-stats"+        (NoArg (setGeneralFlag Opt_StgStats))++  , make_ord_flag defGhcFlag "ddump-cmm"+        (setDumpFlag Opt_D_dump_cmm)+  , make_ord_flag defGhcFlag "ddump-cmm-from-stg"+        (setDumpFlag Opt_D_dump_cmm_from_stg)+  , make_ord_flag defGhcFlag "ddump-cmm-raw"+        (setDumpFlag Opt_D_dump_cmm_raw)+  , make_ord_flag defGhcFlag "ddump-cmm-verbose"+        (setDumpFlag Opt_D_dump_cmm_verbose)+  , make_ord_flag defGhcFlag "ddump-cmm-verbose-by-proc"+        (setDumpFlag Opt_D_dump_cmm_verbose_by_proc)+  , make_ord_flag defGhcFlag "ddump-cmm-cfg"+        (setDumpFlag Opt_D_dump_cmm_cfg)+  , make_ord_flag defGhcFlag "ddump-cmm-cbe"+        (setDumpFlag Opt_D_dump_cmm_cbe)+  , make_ord_flag defGhcFlag "ddump-cmm-switch"+        (setDumpFlag Opt_D_dump_cmm_switch)+  , make_ord_flag defGhcFlag "ddump-cmm-proc"+        (setDumpFlag Opt_D_dump_cmm_proc)+  , make_ord_flag defGhcFlag "ddump-cmm-sp"+        (setDumpFlag Opt_D_dump_cmm_sp)+  , make_ord_flag defGhcFlag "ddump-cmm-sink"+        (setDumpFlag Opt_D_dump_cmm_sink)+  , make_ord_flag defGhcFlag "ddump-cmm-caf"+        (setDumpFlag Opt_D_dump_cmm_caf)+  , make_ord_flag defGhcFlag "ddump-cmm-procmap"+        (setDumpFlag Opt_D_dump_cmm_procmap)+  , make_ord_flag defGhcFlag "ddump-cmm-split"+        (setDumpFlag Opt_D_dump_cmm_split)+  , make_ord_flag defGhcFlag "ddump-cmm-info"+        (setDumpFlag Opt_D_dump_cmm_info)+  , make_ord_flag defGhcFlag "ddump-cmm-cps"+        (setDumpFlag Opt_D_dump_cmm_cps)+  , make_ord_flag defGhcFlag "ddump-cfg-weights"+        (setDumpFlag Opt_D_dump_cfg_weights)+  , make_ord_flag defGhcFlag "ddump-core-stats"+        (setDumpFlag Opt_D_dump_core_stats)+  , make_ord_flag defGhcFlag "ddump-asm"+        (setDumpFlag Opt_D_dump_asm)+  , make_ord_flag defGhcFlag "ddump-asm-native"+        (setDumpFlag Opt_D_dump_asm_native)+  , make_ord_flag defGhcFlag "ddump-asm-liveness"+        (setDumpFlag Opt_D_dump_asm_liveness)+  , make_ord_flag defGhcFlag "ddump-asm-regalloc"+        (setDumpFlag Opt_D_dump_asm_regalloc)+  , make_ord_flag defGhcFlag "ddump-asm-conflicts"+        (setDumpFlag Opt_D_dump_asm_conflicts)+  , make_ord_flag defGhcFlag "ddump-asm-regalloc-stages"+        (setDumpFlag Opt_D_dump_asm_regalloc_stages)+  , make_ord_flag defGhcFlag "ddump-asm-stats"+        (setDumpFlag Opt_D_dump_asm_stats)+  , make_ord_flag defGhcFlag "ddump-asm-expanded"+        (setDumpFlag Opt_D_dump_asm_expanded)+  , make_ord_flag defGhcFlag "ddump-llvm"+        (NoArg $ setObjTarget HscLlvm >> setDumpFlag' Opt_D_dump_llvm)+  , make_ord_flag defGhcFlag "ddump-deriv"+        (setDumpFlag Opt_D_dump_deriv)+  , make_ord_flag defGhcFlag "ddump-ds"+        (setDumpFlag Opt_D_dump_ds)+  , make_ord_flag defGhcFlag "ddump-ds-preopt"+        (setDumpFlag Opt_D_dump_ds_preopt)+  , make_ord_flag defGhcFlag "ddump-foreign"+        (setDumpFlag Opt_D_dump_foreign)+  , make_ord_flag defGhcFlag "ddump-inlinings"+        (setDumpFlag Opt_D_dump_inlinings)+  , make_ord_flag defGhcFlag "ddump-rule-firings"+        (setDumpFlag Opt_D_dump_rule_firings)+  , make_ord_flag defGhcFlag "ddump-rule-rewrites"+        (setDumpFlag Opt_D_dump_rule_rewrites)+  , make_ord_flag defGhcFlag "ddump-simpl-trace"+        (setDumpFlag Opt_D_dump_simpl_trace)+  , make_ord_flag defGhcFlag "ddump-occur-anal"+        (setDumpFlag Opt_D_dump_occur_anal)+  , make_ord_flag defGhcFlag "ddump-parsed"+        (setDumpFlag Opt_D_dump_parsed)+  , make_ord_flag defGhcFlag "ddump-parsed-ast"+        (setDumpFlag Opt_D_dump_parsed_ast)+  , make_ord_flag defGhcFlag "ddump-rn"+        (setDumpFlag Opt_D_dump_rn)+  , make_ord_flag defGhcFlag "ddump-rn-ast"+        (setDumpFlag Opt_D_dump_rn_ast)+  , make_ord_flag defGhcFlag "ddump-simpl"+        (setDumpFlag Opt_D_dump_simpl)+  , make_ord_flag defGhcFlag "ddump-simpl-iterations"+      (setDumpFlag Opt_D_dump_simpl_iterations)+  , make_ord_flag defGhcFlag "ddump-spec"+        (setDumpFlag Opt_D_dump_spec)+  , make_ord_flag defGhcFlag "ddump-prep"+        (setDumpFlag Opt_D_dump_prep)+  , make_ord_flag defGhcFlag "ddump-stg"+        (setDumpFlag Opt_D_dump_stg)+  , make_ord_flag defGhcFlag "ddump-stg-unarised"+        (setDumpFlag Opt_D_dump_stg_unarised)+  , make_ord_flag defGhcFlag "ddump-stg-final"+        (setDumpFlag Opt_D_dump_stg_final)+  , 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"+        (setDumpFlag Opt_D_dump_str_signatures)+  , make_ord_flag defGhcFlag "ddump-cpranal"+        (setDumpFlag Opt_D_dump_cpranal)+  , make_ord_flag defGhcFlag "ddump-cpr-signatures"+        (setDumpFlag Opt_D_dump_cpr_signatures)+  , make_ord_flag defGhcFlag "ddump-tc"+        (setDumpFlag Opt_D_dump_tc)+  , make_ord_flag defGhcFlag "ddump-tc-ast"+        (setDumpFlag Opt_D_dump_tc_ast)+  , make_ord_flag defGhcFlag "ddump-types"+        (setDumpFlag Opt_D_dump_types)+  , make_ord_flag defGhcFlag "ddump-rules"+        (setDumpFlag Opt_D_dump_rules)+  , make_ord_flag defGhcFlag "ddump-cse"+        (setDumpFlag Opt_D_dump_cse)+  , make_ord_flag defGhcFlag "ddump-worker-wrapper"+        (setDumpFlag Opt_D_dump_worker_wrapper)+  , make_ord_flag defGhcFlag "ddump-rn-trace"+        (setDumpFlag Opt_D_dump_rn_trace)+  , make_ord_flag defGhcFlag "ddump-if-trace"+        (setDumpFlag Opt_D_dump_if_trace)+  , make_ord_flag defGhcFlag "ddump-cs-trace"+        (setDumpFlag Opt_D_dump_cs_trace)+  , make_ord_flag defGhcFlag "ddump-tc-trace"+        (NoArg (do setDumpFlag' Opt_D_dump_tc_trace+                   setDumpFlag' Opt_D_dump_cs_trace))+  , make_ord_flag defGhcFlag "ddump-ec-trace"+        (setDumpFlag Opt_D_dump_ec_trace)+  , make_ord_flag defGhcFlag "ddump-vt-trace"+        (setDumpFlag Opt_D_dump_vt_trace)+  , make_ord_flag defGhcFlag "ddump-splices"+        (setDumpFlag Opt_D_dump_splices)+  , make_ord_flag defGhcFlag "dth-dec-file"+        (setDumpFlag Opt_D_th_dec_file)++  , make_ord_flag defGhcFlag "ddump-rn-stats"+        (setDumpFlag Opt_D_dump_rn_stats)+  , make_ord_flag defGhcFlag "ddump-opt-cmm"+        (setDumpFlag Opt_D_dump_opt_cmm)+  , make_ord_flag defGhcFlag "ddump-simpl-stats"+        (setDumpFlag Opt_D_dump_simpl_stats)+  , make_ord_flag defGhcFlag "ddump-bcos"+        (setDumpFlag Opt_D_dump_BCOs)+  , make_ord_flag defGhcFlag "dsource-stats"+        (setDumpFlag Opt_D_source_stats)+  , make_ord_flag defGhcFlag "dverbose-core2core"+        (NoArg $ setVerbosity (Just 2) >> setVerboseCore2Core)+  , make_ord_flag defGhcFlag "dverbose-stg2stg"+        (setDumpFlag Opt_D_verbose_stg2stg)+  , make_ord_flag defGhcFlag "ddump-hi"+        (setDumpFlag Opt_D_dump_hi)+  , make_ord_flag defGhcFlag "ddump-minimal-imports"+        (NoArg (setGeneralFlag Opt_D_dump_minimal_imports))+  , make_ord_flag defGhcFlag "ddump-hpc"+        (setDumpFlag Opt_D_dump_ticked) -- back compat+  , make_ord_flag defGhcFlag "ddump-ticked"+        (setDumpFlag Opt_D_dump_ticked)+  , make_ord_flag defGhcFlag "ddump-mod-cycles"+        (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"+        (NoArg (setGeneralFlag Opt_DumpToFile))+  , make_ord_flag defGhcFlag "ddump-hi-diffs"+        (setDumpFlag Opt_D_dump_hi_diffs)+  , make_ord_flag defGhcFlag "ddump-rtti"+        (setDumpFlag Opt_D_dump_rtti)+  , make_ord_flag defGhcFlag "dcore-lint"+        (NoArg (setGeneralFlag Opt_DoCoreLinting))+  , make_ord_flag defGhcFlag "dstg-lint"+        (NoArg (setGeneralFlag Opt_DoStgLinting))+  , make_ord_flag defGhcFlag "dcmm-lint"+        (NoArg (setGeneralFlag Opt_DoCmmLinting))+  , make_ord_flag defGhcFlag "dasm-lint"+        (NoArg (setGeneralFlag Opt_DoAsmLinting))+  , make_ord_flag defGhcFlag "dannot-lint"+        (NoArg (setGeneralFlag Opt_DoAnnotationLinting))+  , make_ord_flag defGhcFlag "dshow-passes"+        (NoArg $ forceRecompile >> (setVerbosity $ Just 2))+  , make_ord_flag defGhcFlag "dfaststring-stats"+        (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 "dno-typeable-binds"+        (NoArg (setGeneralFlag Opt_NoTypeableBinds))+  , 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)++        ------ Machine dependent (-m<blah>) stuff ---------------------------++  , make_ord_flag defGhcFlag "msse"         (noArg (\d ->+                                                  d { sseVersion = Just SSE1 }))+  , make_ord_flag defGhcFlag "msse2"        (noArg (\d ->+                                                  d { sseVersion = Just SSE2 }))+  , make_ord_flag defGhcFlag "msse3"        (noArg (\d ->+                                                  d { sseVersion = Just SSE3 }))+  , make_ord_flag defGhcFlag "msse4"        (noArg (\d ->+                                                  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 ->+                                                         d { avx512cd = True }))+  , make_ord_flag defGhcFlag "mavx512er"    (noArg (\d ->+                                                         d { avx512er = True }))+  , make_ord_flag defGhcFlag "mavx512f"     (noArg (\d -> d { avx512f = True }))+  , make_ord_flag defGhcFlag "mavx512pf"    (noArg (\d ->+                                                         d { avx512pf = True }))++     ------ Warning opts -------------------------------------------------+  , make_ord_flag defFlag "W"       (NoArg (mapM_ setWarningFlag minusWOpts))+  , make_ord_flag defFlag "Werror"+               (NoArg (do { setGeneralFlag Opt_WarnIsError+                          ; mapM_ setFatalWarningFlag minusWeverythingOpts   }))+  , make_ord_flag defFlag "Wwarn"+               (NoArg (do { unSetGeneralFlag Opt_WarnIsError+                          ; mapM_ unSetFatalWarningFlag minusWeverythingOpts }))+                          -- Opt_WarnIsError is still needed to pass -Werror+                          -- to CPP; see runCpp in SysTools+  , make_dep_flag defFlag "Wnot"    (NoArg (upd (\d ->+                                              d {warningFlags = EnumSet.empty})))+                                             "Use -w or -Wno-everything instead"+  , make_ord_flag defFlag "w"       (NoArg (upd (\d ->+                                              d {warningFlags = EnumSet.empty})))++     -- New-style uniform warning sets+     --+     -- Note that -Weverything > -Wall > -Wextra > -Wdefault > -Wno-everything+  , make_ord_flag defFlag "Weverything"    (NoArg (mapM_+                                           setWarningFlag minusWeverythingOpts))+  , make_ord_flag defFlag "Wno-everything"+                           (NoArg (upd (\d -> d {warningFlags = EnumSet.empty})))++  , make_ord_flag defFlag "Wall"           (NoArg (mapM_+                                                  setWarningFlag minusWallOpts))+  , make_ord_flag defFlag "Wno-all"        (NoArg (mapM_+                                                unSetWarningFlag minusWallOpts))++  , make_ord_flag defFlag "Wextra"         (NoArg (mapM_+                                                     setWarningFlag minusWOpts))+  , make_ord_flag defFlag "Wno-extra"      (NoArg (mapM_+                                                   unSetWarningFlag minusWOpts))++  , make_ord_flag defFlag "Wdefault"       (NoArg (mapM_+                                               setWarningFlag standardWarnings))+  , make_ord_flag defFlag "Wno-default"    (NoArg (mapM_+                                             unSetWarningFlag standardWarnings))++  , make_ord_flag defFlag "Wcompat"        (NoArg (mapM_+                                               setWarningFlag minusWcompatOpts))+  , make_ord_flag defFlag "Wno-compat"     (NoArg (mapM_+                                             unSetWarningFlag minusWcompatOpts))++        ------ Plugin flags ------------------------------------------------+  , make_ord_flag defGhcFlag "fplugin-opt" (hasArg addPluginModuleNameOption)+  , make_ord_flag defGhcFlag "fplugin-trustworthy"+      (NoArg (setGeneralFlag Opt_PluginTrustworthy))+  , make_ord_flag defGhcFlag "fplugin"     (hasArg addPluginModuleName)+  , make_ord_flag defGhcFlag "fclear-plugins" (noArg clearPluginModuleNames)+  , make_ord_flag defGhcFlag "ffrontend-opt" (hasArg addFrontendPluginOption)++        ------ Optimisation flags ------------------------------------------+  , make_dep_flag defGhcFlag "Onot"   (noArgM $ setOptLevel 0 )+                                                            "Use -O0 instead"+  , make_ord_flag defGhcFlag "O"      (optIntSuffixM (\mb_n ->+                                                setOptLevel (mb_n `orElse` 1)))+                -- If the number is missing, use 1++  , make_ord_flag defFlag "fbinary-blob-threshold"+      (intSuffix (\n d -> d { binBlobThreshold = fromIntegral n }))++  , make_ord_flag defFlag "fmax-relevant-binds"+      (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-hole-fits"+      (intSuffix (\n d -> d { maxValidHoleFits = Just n }))+  , make_ord_flag defFlag "fno-max-valid-hole-fits"+      (noArg (\d -> d { maxValidHoleFits = Nothing }))+  , make_ord_flag defFlag "fmax-refinement-hole-fits"+      (intSuffix (\n d -> d { maxRefHoleFits = Just n }))+  , make_ord_flag defFlag "fno-max-refinement-hole-fits"+      (noArg (\d -> d { maxRefHoleFits = Nothing }))+  , make_ord_flag defFlag "frefinement-level-hole-fits"+      (intSuffix (\n d -> d { refLevelHoleFits = Just n }))+  , make_ord_flag defFlag "fno-refinement-level-hole-fits"+      (noArg (\d -> d { refLevelHoleFits = Nothing }))++  , make_dep_flag defGhcFlag "fllvm-pass-vectors-in-regs"+            (noArg id)+            "vectors registers are now passed in registers by default."+  , make_ord_flag defFlag "fmax-uncovered-patterns"+      (intSuffix (\n d -> d { maxUncoveredPatterns = n }))+  , make_ord_flag defFlag "fmax-pmcheck-models"+      (intSuffix (\n d -> d { maxPmCheckModels = n }))+  , make_ord_flag defFlag "fsimplifier-phases"+      (intSuffix (\n d -> d { simplPhases = n }))+  , make_ord_flag defFlag "fmax-simplifier-iterations"+      (intSuffix (\n d -> d { maxSimplIterations = n }))+  , (Deprecated, defFlag "fmax-pmcheck-iterations"+      (intSuffixM (\_ d ->+       do { deprecate $ "use -fmax-pmcheck-models instead"+          ; return d })))+  , make_ord_flag defFlag "fsimpl-tick-factor"+      (intSuffix (\n d -> d { simplTickFactor = n }))+  , make_ord_flag defFlag "fspec-constr-threshold"+      (intSuffix (\n d -> d { specConstrThreshold = Just n }))+  , make_ord_flag defFlag "fno-spec-constr-threshold"+      (noArg (\d -> d { specConstrThreshold = Nothing }))+  , make_ord_flag defFlag "fspec-constr-count"+      (intSuffix (\n d -> d { specConstrCount = Just n }))+  , make_ord_flag defFlag "fno-spec-constr-count"+      (noArg (\d -> d { specConstrCount = Nothing }))+  , make_ord_flag defFlag "fspec-constr-recursive"+      (intSuffix (\n d -> d { specConstrRecursive = n }))+  , make_ord_flag defFlag "fliberate-case-threshold"+      (intSuffix (\n d -> d { liberateCaseThreshold = Just n }))+  , make_ord_flag defFlag "fno-liberate-case-threshold"+      (noArg (\d -> d { liberateCaseThreshold = Nothing }))+  , make_ord_flag defFlag "drule-check"+      (sepArg (\s d -> d { ruleCheck = Just s }))+  , make_ord_flag defFlag "dinline-check"+      (sepArg (\s d -> d { inlineCheck = Just s }))+  , make_ord_flag defFlag "freduction-depth"+      (intSuffix (\n d -> d { reductionDepth = treatZeroAsInf n }))+  , make_ord_flag defFlag "fconstraint-solver-iterations"+      (intSuffix (\n d -> d { solverIterations = treatZeroAsInf n }))+  , (Deprecated, defFlag "fcontext-stack"+      (intSuffixM (\n d ->+       do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"+          ; return $ d { reductionDepth = treatZeroAsInf n } })))+  , (Deprecated, defFlag "ftype-function-depth"+      (intSuffixM (\n d ->+       do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"+          ; return $ d { reductionDepth = treatZeroAsInf n } })))+  , make_ord_flag defFlag "fstrictness-before"+      (intSuffix (\n d -> d { strictnessBefore = n : strictnessBefore d }))+  , make_ord_flag defFlag "ffloat-lam-args"+      (intSuffix (\n d -> d { floatLamArgs = Just n }))+  , make_ord_flag defFlag "ffloat-all-lams"+      (noArg (\d -> d { floatLamArgs = Nothing }))+  , make_ord_flag defFlag "fstg-lift-lams-rec-args"+      (intSuffix (\n d -> d { liftLamsRecArgs = Just n }))+  , make_ord_flag defFlag "fstg-lift-lams-rec-args-any"+      (noArg (\d -> d { liftLamsRecArgs = Nothing }))+  , make_ord_flag defFlag "fstg-lift-lams-non-rec-args"+      (intSuffix (\n d -> d { liftLamsRecArgs = Just n }))+  , make_ord_flag defFlag "fstg-lift-lams-non-rec-args-any"+      (noArg (\d -> d { liftLamsRecArgs = Nothing }))+  , make_ord_flag defFlag "fstg-lift-lams-known"+      (noArg (\d -> d { liftLamsKnown = True }))+  , make_ord_flag defFlag "fno-stg-lift-lams-known"+      (noArg (\d -> d { liftLamsKnown = False }))+  , make_ord_flag defFlag "fproc-alignment"+      (intSuffix (\n d -> d { cmmProcAlignment = Just n }))+  , make_ord_flag defFlag "fblock-layout-weights"+        (HasArg (\s ->+            upd (\d -> d { cfgWeightInfo =+                parseCfgWeights s (cfgWeightInfo d)})))+  , make_ord_flag defFlag "fhistory-size"+      (intSuffix (\n d -> d { historySize = n }))+  , make_ord_flag defFlag "funfolding-creation-threshold"+      (intSuffix   (\n d -> d {ufCreationThreshold = n}))+  , make_ord_flag defFlag "funfolding-use-threshold"+      (intSuffix   (\n d -> d {ufUseThreshold = n}))+  , make_ord_flag defFlag "funfolding-fun-discount"+      (intSuffix   (\n d -> d {ufFunAppDiscount = n}))+  , make_ord_flag defFlag "funfolding-dict-discount"+      (intSuffix   (\n d -> d {ufDictDiscount = n}))+  , make_ord_flag defFlag "funfolding-keeness-factor"+      (floatSuffix (\n d -> d {ufKeenessFactor = n}))+  , make_ord_flag defFlag "fmax-worker-args"+      (intSuffix (\n d -> d {maxWorkerArgs = n}))+  , make_ord_flag defGhciFlag "fghci-hist-size"+      (intSuffix (\n d -> d {ghciHistSize = n}))+  , make_ord_flag defGhcFlag "fmax-inline-alloc-size"+      (intSuffix (\n d -> d { maxInlineAllocSize = n }))+  , make_ord_flag defGhcFlag "fmax-inline-memcpy-insns"+      (intSuffix (\n d -> d { maxInlineMemcpyInsns = n }))+  , make_ord_flag defGhcFlag "fmax-inline-memset-insns"+      (intSuffix (\n d -> d { maxInlineMemsetInsns = n }))+  , make_ord_flag defGhcFlag "dinitial-unique"+      (intSuffix (\n d -> d { initialUnique = n }))+  , make_ord_flag defGhcFlag "dunique-increment"+      (intSuffix (\n d -> d { uniqueIncrement = n }))++        ------ Profiling ----------------------------------------------------++        -- OLD profiling flags+  , make_dep_flag defGhcFlag "auto-all"+                    (noArg (\d -> d { profAuto = ProfAutoAll } ))+                    "Use -fprof-auto instead"+  , make_dep_flag defGhcFlag "no-auto-all"+                    (noArg (\d -> d { profAuto = NoProfAuto } ))+                    "Use -fno-prof-auto instead"+  , make_dep_flag defGhcFlag "auto"+                    (noArg (\d -> d { profAuto = ProfAutoExports } ))+                    "Use -fprof-auto-exported instead"+  , make_dep_flag defGhcFlag "no-auto"+            (noArg (\d -> d { profAuto = NoProfAuto } ))+                    "Use -fno-prof-auto instead"+  , make_dep_flag defGhcFlag "caf-all"+            (NoArg (setGeneralFlag Opt_AutoSccsOnIndividualCafs))+                    "Use -fprof-cafs instead"+  , make_dep_flag defGhcFlag "no-caf-all"+            (NoArg (unSetGeneralFlag Opt_AutoSccsOnIndividualCafs))+                    "Use -fno-prof-cafs instead"++        -- NEW profiling flags+  , make_ord_flag defGhcFlag "fprof-auto"+      (noArg (\d -> d { profAuto = ProfAutoAll } ))+  , make_ord_flag defGhcFlag "fprof-auto-top"+      (noArg (\d -> d { profAuto = ProfAutoTop } ))+  , make_ord_flag defGhcFlag "fprof-auto-exported"+      (noArg (\d -> d { profAuto = ProfAutoExports } ))+  , make_ord_flag defGhcFlag "fprof-auto-calls"+      (noArg (\d -> d { profAuto = ProfAutoCalls } ))+  , make_ord_flag defGhcFlag "fno-prof-auto"+      (noArg (\d -> d { profAuto = NoProfAuto } ))++        ------ Compiler flags -----------------------------------------------++  , make_ord_flag defGhcFlag "fasm"             (NoArg (setObjTarget HscAsm))+  , make_ord_flag defGhcFlag "fvia-c"           (NoArg+         (deprecate $ "The -fvia-c flag does nothing; " +++                      "it will be removed in a future GHC release"))+  , make_ord_flag defGhcFlag "fvia-C"           (NoArg+         (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 ->+                  d { ghcLink=NoLink }) >> setTarget HscNothing))+  , make_ord_flag defFlag "fbyte-code"+      (noArgM $ \dflags -> do+        setTarget HscInterpreted+        pure $ gopt_set dflags Opt_ByteCode)+  , make_ord_flag defFlag "fobject-code"     $ NoArg $ do+      dflags <- liftEwM getCmdLineState+      setTarget $ defaultObjectTarget dflags++  , make_dep_flag defFlag "fglasgow-exts"+      (NoArg enableGlasgowExts) "Use individual extensions instead"+  , make_dep_flag defFlag "fno-glasgow-exts"+      (NoArg disableGlasgowExts) "Use individual extensions instead"+  , make_ord_flag defFlag "Wunused-binds" (NoArg enableUnusedBinds)+  , make_ord_flag defFlag "Wno-unused-binds" (NoArg disableUnusedBinds)+  , make_ord_flag defHiddenFlag "fwarn-unused-binds" (NoArg enableUnusedBinds)+  , make_ord_flag defHiddenFlag "fno-warn-unused-binds" (NoArg+                                                            disableUnusedBinds)++        ------ Safe Haskell flags -------------------------------------------+  , make_ord_flag defFlag "fpackage-trust"   (NoArg setPackageTrust)+  , make_ord_flag defFlag "fno-safe-infer"   (noArg (\d ->+                                                    d { safeInfer = False }))+  , make_ord_flag defFlag "fno-safe-haskell" (NoArg (setSafeHaskell Sf_Ignore))++        ------ position independent flags  ----------------------------------+  , make_ord_flag defGhcFlag "fPIC"          (NoArg (setGeneralFlag Opt_PIC))+  , make_ord_flag defGhcFlag "fno-PIC"       (NoArg (unSetGeneralFlag Opt_PIC))+  , make_ord_flag defGhcFlag "fPIE"          (NoArg (setGeneralFlag Opt_PIC))+  , make_ord_flag defGhcFlag "fno-PIE"       (NoArg (unSetGeneralFlag Opt_PIC))++         ------ Debugging flags ----------------------------------------------+  , make_ord_flag defGhcFlag "g"             (OptIntSuffix setDebugLevel)+ ]+ ++ map (mkFlag turnOn  ""          setGeneralFlag    ) negatableFlagsDeps+ ++ map (mkFlag turnOff "no-"       unSetGeneralFlag  ) negatableFlagsDeps+ ++ map (mkFlag turnOn  "d"         setGeneralFlag    ) dFlagsDeps+ ++ map (mkFlag turnOff "dno-"      unSetGeneralFlag  ) dFlagsDeps+ ++ map (mkFlag turnOn  "f"         setGeneralFlag    ) fFlagsDeps+ ++ map (mkFlag turnOff "fno-"      unSetGeneralFlag  ) fFlagsDeps+ ++ map (mkFlag turnOn  "W"         setWarningFlag    ) wWarningFlagsDeps+ ++ map (mkFlag turnOff "Wno-"      unSetWarningFlag  ) wWarningFlagsDeps+ ++ map (mkFlag turnOn  "Werror="   setWErrorFlag )     wWarningFlagsDeps+ ++ map (mkFlag turnOn  "Wwarn="     unSetFatalWarningFlag )+                                                        wWarningFlagsDeps+ ++ map (mkFlag turnOn  "Wno-error=" unSetFatalWarningFlag )+                                                        wWarningFlagsDeps+ ++ map (mkFlag turnOn  "fwarn-"    setWarningFlag   . hideFlag)+    wWarningFlagsDeps+ ++ map (mkFlag turnOff "fno-warn-" unSetWarningFlag . hideFlag)+    wWarningFlagsDeps+ ++ [ (NotDeprecated, unrecognisedWarning "W"),+      (Deprecated,    unrecognisedWarning "fwarn-"),+      (Deprecated,    unrecognisedWarning "fno-warn-") ]+ ++ [ make_ord_flag defFlag "Werror=compat"+        (NoArg (mapM_ setWErrorFlag minusWcompatOpts))+    , make_ord_flag defFlag "Wno-error=compat"+        (NoArg (mapM_ unSetFatalWarningFlag minusWcompatOpts))+    , make_ord_flag defFlag "Wwarn=compat"+        (NoArg (mapM_ unSetFatalWarningFlag minusWcompatOpts)) ]+ ++ map (mkFlag turnOn  "f"         setExtensionFlag  ) fLangFlagsDeps+ ++ map (mkFlag turnOff "fno-"      unSetExtensionFlag) fLangFlagsDeps+ ++ map (mkFlag turnOn  "X"         setExtensionFlag  ) xFlagsDeps+ ++ map (mkFlag turnOff "XNo"       unSetExtensionFlag) xFlagsDeps+ ++ map (mkFlag turnOn  "X"         setLanguage       ) languageFlagsDeps+ ++ map (mkFlag turnOn  "X"         setSafeHaskell    ) safeHaskellFlagsDeps+ ++ [ make_dep_flag defFlag "XGenerics"+        (NoArg $ return ())+                  ("it does nothing; look into -XDefaultSignatures " +++                   "and -XDeriveGeneric for generic programming support.")+    , make_dep_flag defFlag "XNoGenerics"+        (NoArg $ return ())+               ("it does nothing; look into -XDefaultSignatures and " +++                  "-XDeriveGeneric for generic programming support.") ]++-- | This is where we handle unrecognised warning flags. We only issue a warning+-- if -Wunrecognised-warning-flags is set. See #11429 for context.+unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)+unrecognisedWarning prefix = defHiddenFlag prefix (Prefix action)+  where+    action :: String -> EwM (CmdLineP DynFlags) ()+    action flag = do+      f <- wopt Opt_WarnUnrecognisedWarningFlags <$> liftEwM getCmdLineState+      when f $ addFlagWarn Cmd.ReasonUnrecognisedFlag $+        "unrecognised warning flag: -" ++ prefix ++ flag++-- See Note [Supporting CLI completion]+package_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]+package_flags_deps = [+        ------- Packages ----------------------------------------------------+    make_ord_flag defFlag "package-db"+      (HasArg (addPkgDbRef . PkgDbPath))+  , make_ord_flag defFlag "clear-package-db"      (NoArg clearPkgDb)+  , make_ord_flag defFlag "no-global-package-db"  (NoArg removeGlobalPkgDb)+  , make_ord_flag defFlag "no-user-package-db"    (NoArg removeUserPkgDb)+  , make_ord_flag defFlag "global-package-db"+      (NoArg (addPkgDbRef GlobalPkgDb))+  , make_ord_flag defFlag "user-package-db"+      (NoArg (addPkgDbRef UserPkgDb))+    -- backwards compat with GHC<=7.4 :+  , make_dep_flag defFlag "package-conf"+      (HasArg $ addPkgDbRef . PkgDbPath) "Use -package-db instead"+  , make_dep_flag defFlag "no-user-package-conf"+      (NoArg removeUserPkgDb)              "Use -no-user-package-db instead"+  , make_ord_flag defGhcFlag "package-name"       (HasArg $ \name -> do+                                      upd (setUnitId name))+                                      -- TODO: Since we JUST deprecated+                                      -- -this-package-key, let's keep this+                                      -- undeprecated for another cycle.+                                      -- Deprecate this eventually.+                                      -- deprecate "Use -this-unit-id instead")+  , make_dep_flag defGhcFlag "this-package-key"   (HasArg $ upd . setUnitId)+                                                  "Use -this-unit-id instead"+  , make_ord_flag defGhcFlag "this-unit-id"       (hasArg setUnitId)+  , make_ord_flag defFlag "package"               (HasArg exposePackage)+  , make_ord_flag defFlag "plugin-package-id"     (HasArg exposePluginPackageId)+  , make_ord_flag defFlag "plugin-package"        (HasArg exposePluginPackage)+  , make_ord_flag defFlag "package-id"            (HasArg exposePackageId)+  , make_ord_flag defFlag "hide-package"          (HasArg hidePackage)+  , make_ord_flag defFlag "hide-all-packages"+      (NoArg (setGeneralFlag Opt_HideAllPackages))+  , make_ord_flag defFlag "hide-all-plugin-packages"+      (NoArg (setGeneralFlag Opt_HideAllPluginPackages))+  , make_ord_flag defFlag "package-env"           (HasArg setPackageEnv)+  , make_ord_flag defFlag "ignore-package"        (HasArg ignorePackage)+  , make_dep_flag defFlag "syslib" (HasArg exposePackage) "Use -package instead"+  , make_ord_flag defFlag "distrust-all-packages"+      (NoArg (setGeneralFlag Opt_DistrustAllPackages))+  , make_ord_flag defFlag "trust"                 (HasArg trustPackage)+  , make_ord_flag defFlag "distrust"              (HasArg distrustPackage)+  ]+  where+    setPackageEnv env = upd $ \s -> s { packageEnv = Just env }++-- | Make a list of flags for shell completion.+-- Filter all available flags into two groups, for interactive GHC vs all other.+flagsForCompletion :: Bool -> [String]+flagsForCompletion isInteractive+    = [ '-':flagName flag+      | flag <- flagsAll+      , modeFilter (flagGhcMode flag)+      ]+    where+      modeFilter AllModes = True+      modeFilter OnlyGhci = isInteractive+      modeFilter OnlyGhc = not isInteractive+      modeFilter HiddenFlag = False++type TurnOnFlag = Bool   -- True  <=> we are turning the flag on+                         -- False <=> we are turning the flag off+turnOn  :: TurnOnFlag; turnOn  = True+turnOff :: TurnOnFlag; turnOff = False++data FlagSpec flag+   = FlagSpec+       { flagSpecName :: String   -- ^ Flag in string form+       , flagSpecFlag :: flag     -- ^ Flag in internal form+       , flagSpecAction :: (TurnOnFlag -> DynP ())+           -- ^ Extra action to run when the flag is found+           -- Typically, emit a warning or error+       , flagSpecGhcMode :: GhcFlagMode+           -- ^ In which ghc mode the flag has effect+       }++-- | Define a new flag.+flagSpec :: String -> flag -> (Deprecation, FlagSpec flag)+flagSpec name flag = flagSpec' name flag nop++-- | Define a new flag with an effect.+flagSpec' :: String -> flag -> (TurnOnFlag -> DynP ())+          -> (Deprecation, FlagSpec flag)+flagSpec' name flag act = (NotDeprecated, FlagSpec name flag act AllModes)++-- | Define a new deprecated flag with an effect.+depFlagSpecOp :: String -> flag -> (TurnOnFlag -> DynP ()) -> String+            -> (Deprecation, FlagSpec flag)+depFlagSpecOp name flag act dep =+    (Deprecated, snd (flagSpec' name flag (\f -> act f >> deprecate dep)))++-- | Define a new deprecated flag.+depFlagSpec :: String -> flag -> String+            -> (Deprecation, FlagSpec flag)+depFlagSpec name flag dep = depFlagSpecOp name flag nop dep++-- | Define a new deprecated flag with an effect where the deprecation message+-- depends on the flag value+depFlagSpecOp' :: String+             -> flag+             -> (TurnOnFlag -> DynP ())+             -> (TurnOnFlag -> String)+             -> (Deprecation, FlagSpec flag)+depFlagSpecOp' name flag act dep =+    (Deprecated, FlagSpec name flag (\f -> act f >> (deprecate $ dep f))+                                                                       AllModes)++-- | Define a new deprecated flag where the deprecation message+-- depends on the flag value+depFlagSpec' :: String+             -> flag+             -> (TurnOnFlag -> String)+             -> (Deprecation, FlagSpec flag)+depFlagSpec' name flag dep = depFlagSpecOp' name flag nop dep+++-- | Define a new deprecated flag where the deprecation message+-- is shown depending on the flag value+depFlagSpecCond :: String+                -> flag+                -> (TurnOnFlag -> Bool)+                -> String+                -> (Deprecation, FlagSpec flag)+depFlagSpecCond name flag cond dep =+    (Deprecated, FlagSpec name flag (\f -> when (cond f) $ deprecate dep)+                                                                       AllModes)++-- | Define a new flag for GHCi.+flagGhciSpec :: String -> flag -> (Deprecation, FlagSpec flag)+flagGhciSpec name flag = flagGhciSpec' name flag nop++-- | Define a new flag for GHCi with an effect.+flagGhciSpec' :: String -> flag -> (TurnOnFlag -> DynP ())+              -> (Deprecation, FlagSpec flag)+flagGhciSpec' name flag act = (NotDeprecated, FlagSpec name flag act OnlyGhci)++-- | Define a new flag invisible to CLI completion.+flagHiddenSpec :: String -> flag -> (Deprecation, FlagSpec flag)+flagHiddenSpec name flag = flagHiddenSpec' name flag nop++-- | Define a new flag invisible to CLI completion with an effect.+flagHiddenSpec' :: String -> flag -> (TurnOnFlag -> DynP ())+                -> (Deprecation, FlagSpec flag)+flagHiddenSpec' name flag act = (NotDeprecated, FlagSpec name flag act+                                                                     HiddenFlag)++-- | Hide a 'FlagSpec' from being displayed in @--show-options@.+--+-- This is for example useful for flags that are obsolete, but should not+-- (yet) be deprecated for compatibility reasons.+hideFlag :: (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)+hideFlag (dep, fs) = (dep, fs { flagSpecGhcMode = HiddenFlag })++mkFlag :: TurnOnFlag            -- ^ True <=> it should be turned on+       -> String                -- ^ The flag prefix+       -> (flag -> DynP ())     -- ^ What to do when the flag is found+       -> (Deprecation, FlagSpec flag)  -- ^ Specification of+                                        -- this particular flag+       -> (Deprecation, Flag (CmdLineP DynFlags))+mkFlag turn_on flagPrefix f (dep, (FlagSpec name flag extra_action mode))+    = (dep,+       Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on)) mode)++deprecatedForExtension :: String -> TurnOnFlag -> String+deprecatedForExtension lang turn_on+    = "use -X" ++ flag +++      " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead"+    where+      flag | turn_on   = lang+           | otherwise = "No" ++ lang++useInstead :: String -> String -> TurnOnFlag -> String+useInstead prefix flag turn_on+  = "Use " ++ prefix ++ no ++ flag ++ " instead"+  where+    no = if turn_on then "" else "no-"++nop :: TurnOnFlag -> DynP ()+nop _ = return ()++-- | Find the 'FlagSpec' for a 'WarningFlag'.+flagSpecOf :: WarningFlag -> Maybe (FlagSpec WarningFlag)+flagSpecOf flag = listToMaybe $ filter check wWarningFlags+  where+    check fs = flagSpecFlag fs == flag++-- | These @-W\<blah\>@ flags can all be reversed with @-Wno-\<blah\>@+wWarningFlags :: [FlagSpec WarningFlag]+wWarningFlags = map snd (sortBy (comparing fst) wWarningFlagsDeps)++wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]+wWarningFlagsDeps = [+-- See Note [Updating flag description in the User's Guide]+-- See Note [Supporting CLI completion]+-- Please keep the list of flags below sorted alphabetically+  flagSpec "alternative-layout-rule-transitional"+                                      Opt_WarnAlternativeLayoutRuleTransitional,+  depFlagSpec "auto-orphans"             Opt_WarnAutoOrphans+    "it has no effect",+  flagSpec "cpp-undef"                   Opt_WarnCPPUndef,+  flagSpec "unbanged-strict-patterns"    Opt_WarnUnbangedStrictPatterns,+  flagSpec "deferred-type-errors"        Opt_WarnDeferredTypeErrors,+  flagSpec "deferred-out-of-scope-variables"+                                         Opt_WarnDeferredOutOfScopeVariables,+  flagSpec "deprecations"                Opt_WarnWarningsDeprecations,+  flagSpec "deprecated-flags"            Opt_WarnDeprecatedFlags,+  flagSpec "deriving-defaults"           Opt_WarnDerivingDefaults,+  flagSpec "deriving-typeable"           Opt_WarnDerivingTypeable,+  flagSpec "dodgy-exports"               Opt_WarnDodgyExports,+  flagSpec "dodgy-foreign-imports"       Opt_WarnDodgyForeignImports,+  flagSpec "dodgy-imports"               Opt_WarnDodgyImports,+  flagSpec "empty-enumerations"          Opt_WarnEmptyEnumerations,+  depFlagSpec "duplicate-constraints"    Opt_WarnDuplicateConstraints+    "it is subsumed by -Wredundant-constraints",+  flagSpec "redundant-constraints"       Opt_WarnRedundantConstraints,+  flagSpec "duplicate-exports"           Opt_WarnDuplicateExports,+  depFlagSpec "hi-shadowing"                Opt_WarnHiShadows+    "it is not used, and was never implemented",+  flagSpec "inaccessible-code"           Opt_WarnInaccessibleCode,+  flagSpec "implicit-prelude"            Opt_WarnImplicitPrelude,+  depFlagSpec "implicit-kind-vars"       Opt_WarnImplicitKindVars+    "it is now an error",+  flagSpec "incomplete-patterns"         Opt_WarnIncompletePatterns,+  flagSpec "incomplete-record-updates"   Opt_WarnIncompletePatternsRecUpd,+  flagSpec "incomplete-uni-patterns"     Opt_WarnIncompleteUniPatterns,+  flagSpec "inline-rule-shadowing"       Opt_WarnInlineRuleShadowing,+  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,+  flagSpec "missing-methods"             Opt_WarnMissingMethods,+  flagSpec "missing-monadfail-instances" Opt_WarnMissingMonadFailInstances,+  flagSpec "semigroup"                   Opt_WarnSemigroup,+  flagSpec "missing-signatures"          Opt_WarnMissingSignatures,+  depFlagSpec "missing-exported-sigs"    Opt_WarnMissingExportedSignatures+    "it is replaced by -Wmissing-exported-signatures",+  flagSpec "missing-exported-signatures" Opt_WarnMissingExportedSignatures,+  flagSpec "monomorphism-restriction"    Opt_WarnMonomorphism,+  flagSpec "name-shadowing"              Opt_WarnNameShadowing,+  flagSpec "noncanonical-monad-instances"+                                         Opt_WarnNonCanonicalMonadInstances,+  depFlagSpec "noncanonical-monadfail-instances"+                                         Opt_WarnNonCanonicalMonadInstances+    "fail is no longer a method of Monad",+  flagSpec "noncanonical-monoid-instances"+                                         Opt_WarnNonCanonicalMonoidInstances,+  flagSpec "orphans"                     Opt_WarnOrphans,+  flagSpec "overflowed-literals"         Opt_WarnOverflowedLiterals,+  flagSpec "overlapping-patterns"        Opt_WarnOverlappingPatterns,+  flagSpec "missed-specialisations"      Opt_WarnMissedSpecs,+  flagSpec "missed-specializations"      Opt_WarnMissedSpecs,+  flagSpec "all-missed-specialisations"  Opt_WarnAllMissedSpecs,+  flagSpec "all-missed-specializations"  Opt_WarnAllMissedSpecs,+  flagSpec' "safe"                       Opt_WarnSafe setWarnSafe,+  flagSpec "trustworthy-safe"            Opt_WarnTrustworthySafe,+  flagSpec "inferred-safe-imports"       Opt_WarnInferredSafeImports,+  flagSpec "missing-safe-haskell-mode"   Opt_WarnMissingSafeHaskellMode,+  flagSpec "tabs"                        Opt_WarnTabs,+  flagSpec "type-defaults"               Opt_WarnTypeDefaults,+  flagSpec "typed-holes"                 Opt_WarnTypedHoles,+  flagSpec "partial-type-signatures"     Opt_WarnPartialTypeSignatures,+  flagSpec "unrecognised-pragmas"        Opt_WarnUnrecognisedPragmas,+  flagSpec' "unsafe"                     Opt_WarnUnsafe setWarnUnsafe,+  flagSpec "unsupported-calling-conventions"+                                         Opt_WarnUnsupportedCallingConventions,+  flagSpec "unsupported-llvm-version"    Opt_WarnUnsupportedLlvmVersion,+  flagSpec "missed-extra-shared-lib"     Opt_WarnMissedExtraSharedLib,+  flagSpec "unticked-promoted-constructors"+                                         Opt_WarnUntickedPromotedConstructors,+  flagSpec "unused-do-bind"              Opt_WarnUnusedDoBind,+  flagSpec "unused-foralls"              Opt_WarnUnusedForalls,+  flagSpec "unused-imports"              Opt_WarnUnusedImports,+  flagSpec "unused-local-binds"          Opt_WarnUnusedLocalBinds,+  flagSpec "unused-matches"              Opt_WarnUnusedMatches,+  flagSpec "unused-pattern-binds"        Opt_WarnUnusedPatternBinds,+  flagSpec "unused-top-binds"            Opt_WarnUnusedTopBinds,+  flagSpec "unused-type-patterns"        Opt_WarnUnusedTypePatterns,+  flagSpec "unused-record-wildcards"     Opt_WarnUnusedRecordWildcards,+  flagSpec "redundant-record-wildcards"  Opt_WarnRedundantRecordWildcards,+  flagSpec "warnings-deprecations"       Opt_WarnWarningsDeprecations,+  flagSpec "wrong-do-bind"               Opt_WarnWrongDoBind,+  flagSpec "missing-pattern-synonym-signatures"+                                    Opt_WarnMissingPatternSynonymSignatures,+  flagSpec "missing-deriving-strategies" Opt_WarnMissingDerivingStrategies,+  flagSpec "simplifiable-class-constraints" Opt_WarnSimplifiableClassConstraints,+  flagSpec "missing-home-modules"        Opt_WarnMissingHomeModules,+  flagSpec "unrecognised-warning-flags"  Opt_WarnUnrecognisedWarningFlags,+  flagSpec "star-binder"                 Opt_WarnStarBinder,+  flagSpec "star-is-type"                Opt_WarnStarIsType,+  depFlagSpec "missing-space-after-bang" Opt_WarnSpaceAfterBang+    "bang patterns can no longer be written with a space",+  flagSpec "partial-fields"              Opt_WarnPartialFields,+  flagSpec "prepositive-qualified-module"+                                         Opt_WarnPrepositiveQualifiedModule,+  flagSpec "unused-packages"             Opt_WarnUnusedPackages,+  flagSpec "compat-unqualified-imports"  Opt_WarnCompatUnqualifiedImports+ ]++-- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@+negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]+negatableFlagsDeps = [+  flagGhciSpec "ignore-dot-ghci"         Opt_IgnoreDotGhci ]++-- | These @-d\<blah\>@ flags can all be reversed with @-dno-\<blah\>@+dFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]+dFlagsDeps = [+-- See Note [Updating flag description in the User's Guide]+-- See Note [Supporting CLI completion]+-- Please keep the list of flags below sorted alphabetically+  flagSpec "ppr-case-as-let"            Opt_PprCaseAsLet,+  depFlagSpec' "ppr-ticks"              Opt_PprShowTicks+     (\turn_on -> useInstead "-d" "suppress-ticks" (not turn_on)),+  flagSpec "suppress-ticks"             Opt_SuppressTicks,+  depFlagSpec' "suppress-stg-free-vars" Opt_SuppressStgExts+     (useInstead "-d" "suppress-stg-exts"),+  flagSpec "suppress-stg-exts"          Opt_SuppressStgExts,+  flagSpec "suppress-coercions"         Opt_SuppressCoercions,+  flagSpec "suppress-idinfo"            Opt_SuppressIdInfo,+  flagSpec "suppress-unfoldings"        Opt_SuppressUnfoldings,+  flagSpec "suppress-module-prefixes"   Opt_SuppressModulePrefixes,+  flagSpec "suppress-timestamps"        Opt_SuppressTimestamps,+  flagSpec "suppress-type-applications" Opt_SuppressTypeApplications,+  flagSpec "suppress-type-signatures"   Opt_SuppressTypeSignatures,+  flagSpec "suppress-uniques"           Opt_SuppressUniques,+  flagSpec "suppress-var-kinds"         Opt_SuppressVarKinds+  ]++-- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@+fFlags :: [FlagSpec GeneralFlag]+fFlags = map snd fFlagsDeps++fFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]+fFlagsDeps = [+-- See Note [Updating flag description in the User's Guide]+-- See Note [Supporting CLI completion]+-- Please keep the list of flags below sorted alphabetically+  flagSpec "asm-shortcutting"                 Opt_AsmShortcutting,+  flagGhciSpec "break-on-error"               Opt_BreakOnError,+  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,+  flagSpec "cmm-sink"                         Opt_CmmSink,+  flagSpec "cse"                              Opt_CSE,+  flagSpec "stg-cse"                          Opt_StgCSE,+  flagSpec "stg-lift-lams"                    Opt_StgLiftLams,+  flagSpec "cpr-anal"                         Opt_CprAnal,+  flagSpec "defer-diagnostics"                Opt_DeferDiagnostics,+  flagSpec "defer-type-errors"                Opt_DeferTypeErrors,+  flagSpec "defer-typed-holes"                Opt_DeferTypedHoles,+  flagSpec "defer-out-of-scope-variables"     Opt_DeferOutOfScopeVariables,+  flagSpec "diagnostics-show-caret"           Opt_DiagnosticsShowCaret,+  flagSpec "dicts-cheap"                      Opt_DictsCheap,+  flagSpec "dicts-strict"                     Opt_DictsStrict,+  flagSpec "dmd-tx-dict-sel"                  Opt_DmdTxDictSel,+  flagSpec "do-eta-reduction"                 Opt_DoEtaReduction,+  flagSpec "do-lambda-eta-expansion"          Opt_DoLambdaEtaExpansion,+  flagSpec "eager-blackholing"                Opt_EagerBlackHoling,+  flagSpec "embed-manifest"                   Opt_EmbedManifest,+  flagSpec "enable-rewrite-rules"             Opt_EnableRewriteRules,+  flagSpec "enable-th-splice-warnings"        Opt_EnableThSpliceWarnings,+  flagSpec "error-spans"                      Opt_ErrorSpans,+  flagSpec "excess-precision"                 Opt_ExcessPrecision,+  flagSpec "expose-all-unfoldings"            Opt_ExposeAllUnfoldings,+  flagSpec "external-dynamic-refs"            Opt_ExternalDynamicRefs,+  flagSpec "external-interpreter"             Opt_ExternalInterpreter,+  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,+  flagSpec "ghci-history"                     Opt_GhciHistory,+  flagSpec "ghci-leak-check"                  Opt_GhciLeakCheck,+  flagSpec "validate-ide-info"                Opt_ValidateHie,+  flagGhciSpec "local-ghci-history"           Opt_LocalGhciHistory,+  flagGhciSpec "no-it"                        Opt_NoIt,+  flagSpec "ghci-sandbox"                     Opt_GhciSandbox,+  flagSpec "helpful-errors"                   Opt_HelpfulErrors,+  flagSpec "hpc"                              Opt_Hpc,+  flagSpec "ignore-asserts"                   Opt_IgnoreAsserts,+  flagSpec "ignore-interface-pragmas"         Opt_IgnoreInterfacePragmas,+  flagGhciSpec "implicit-import-qualified"    Opt_ImplicitImportQualified,+  flagSpec "irrefutable-tuples"               Opt_IrrefutableTuples,+  flagSpec "keep-going"                       Opt_KeepGoing,+  flagSpec "kill-absence"                     Opt_KillAbsence,+  flagSpec "kill-one-shot"                    Opt_KillOneShot,+  flagSpec "late-dmd-anal"                    Opt_LateDmdAnal,+  flagSpec "late-specialise"                  Opt_LateSpecialise,+  flagSpec "liberate-case"                    Opt_LiberateCase,+  flagHiddenSpec "llvm-tbaa"                  Opt_LlvmTBAA,+  flagHiddenSpec "llvm-fill-undef-with-garbage" Opt_LlvmFillUndefWithGarbage,+  flagSpec "loopification"                    Opt_Loopification,+  flagSpec "block-layout-cfg"                 Opt_CfgBlocklayout,+  flagSpec "block-layout-weightless"          Opt_WeightlessBlocklayout,+  flagSpec "omit-interface-pragmas"           Opt_OmitInterfacePragmas,+  flagSpec "omit-yields"                      Opt_OmitYields,+  flagSpec "optimal-applicative-do"           Opt_OptimalApplicativeDo,+  flagSpec "pedantic-bottoms"                 Opt_PedanticBottoms,+  flagSpec "pre-inlining"                     Opt_SimplPreInlining,+  flagGhciSpec "print-bind-contents"          Opt_PrintBindContents,+  flagGhciSpec "print-bind-result"            Opt_PrintBindResult,+  flagGhciSpec "print-evld-with-show"         Opt_PrintEvldWithShow,+  flagSpec "print-explicit-foralls"           Opt_PrintExplicitForalls,+  flagSpec "print-explicit-kinds"             Opt_PrintExplicitKinds,+  flagSpec "print-explicit-coercions"         Opt_PrintExplicitCoercions,+  flagSpec "print-explicit-runtime-reps"      Opt_PrintExplicitRuntimeReps,+  flagSpec "print-equality-relations"         Opt_PrintEqualityRelations,+  flagSpec "print-axiom-incomps"              Opt_PrintAxiomIncomps,+  flagSpec "print-unicode-syntax"             Opt_PrintUnicodeSyntax,+  flagSpec "print-expanded-synonyms"          Opt_PrintExpandedSynonyms,+  flagSpec "print-potential-instances"        Opt_PrintPotentialInstances,+  flagSpec "print-typechecker-elaboration"    Opt_PrintTypecheckerElaboration,+  flagSpec "prof-cafs"                        Opt_AutoSccsOnIndividualCafs,+  flagSpec "prof-count-entries"               Opt_ProfCountEntries,+  flagSpec "regs-graph"                       Opt_RegsGraph,+  flagSpec "regs-iterative"                   Opt_RegsIterative,+  depFlagSpec' "rewrite-rules"                Opt_EnableRewriteRules+   (useInstead "-f" "enable-rewrite-rules"),+  flagSpec "shared-implib"                    Opt_SharedImplib,+  flagSpec "spec-constr"                      Opt_SpecConstr,+  flagSpec "spec-constr-keen"                 Opt_SpecConstrKeen,+  flagSpec "specialise"                       Opt_Specialise,+  flagSpec "specialize"                       Opt_Specialise,+  flagSpec "specialise-aggressively"          Opt_SpecialiseAggressively,+  flagSpec "specialize-aggressively"          Opt_SpecialiseAggressively,+  flagSpec "cross-module-specialise"          Opt_CrossModuleSpecialise,+  flagSpec "cross-module-specialize"          Opt_CrossModuleSpecialise,+  flagSpec "static-argument-transformation"   Opt_StaticArgumentTransformation,+  flagSpec "strictness"                       Opt_Strictness,+  flagSpec "use-rpaths"                       Opt_RPath,+  flagSpec "write-interface"                  Opt_WriteInterface,+  flagSpec "write-ide-info"                   Opt_WriteHie,+  flagSpec "unbox-small-strict-fields"        Opt_UnboxSmallStrictFields,+  flagSpec "unbox-strict-fields"              Opt_UnboxStrictFields,+  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 "num-constant-folding"             Opt_NumConstantFolding,+  flagSpec "show-warning-groups"              Opt_ShowWarnGroups,+  flagSpec "hide-source-paths"                Opt_HideSourcePaths,+  flagSpec "show-loaded-modules"              Opt_ShowLoadedModules,+  flagSpec "whole-archive-hs-libs"            Opt_WholeArchiveHsLibs,+  flagSpec "keep-cafs"                        Opt_KeepCAFs+  ]+  ++ fHoleFlags++-- | These @-f\<blah\>@ flags have to do with the typed-hole error message or+-- the valid hole fits in that message. See Note [Valid hole fits include ...]+-- in the TcHoleErrors module. These flags can all be reversed with+-- @-fno-\<blah\>@+fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)]+fHoleFlags = [+  flagSpec "show-hole-constraints"            Opt_ShowHoleConstraints,+  depFlagSpec' "show-valid-substitutions"     Opt_ShowValidHoleFits+   (useInstead "-f" "show-valid-hole-fits"),+  flagSpec "show-valid-hole-fits"             Opt_ShowValidHoleFits,+  -- Sorting settings+  flagSpec "sort-valid-hole-fits"             Opt_SortValidHoleFits,+  flagSpec "sort-by-size-hole-fits"           Opt_SortBySizeHoleFits,+  flagSpec "sort-by-subsumption-hole-fits"    Opt_SortBySubsumHoleFits,+  flagSpec "abstract-refinement-hole-fits"    Opt_AbstractRefHoleFits,+  -- Output format settings+  flagSpec "show-hole-matches-of-hole-fits"   Opt_ShowMatchesOfHoleFits,+  flagSpec "show-provenance-of-hole-fits"     Opt_ShowProvOfHoleFits,+  flagSpec "show-type-of-hole-fits"           Opt_ShowTypeOfHoleFits,+  flagSpec "show-type-app-of-hole-fits"       Opt_ShowTypeAppOfHoleFits,+  flagSpec "show-type-app-vars-of-hole-fits"  Opt_ShowTypeAppVarsOfHoleFits,+  flagSpec "show-docs-of-hole-fits"           Opt_ShowDocsOfHoleFits,+  flagSpec "unclutter-valid-hole-fits"        Opt_UnclutterValidHoleFits+  ]++-- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@+fLangFlags :: [FlagSpec LangExt.Extension]+fLangFlags = map snd fLangFlagsDeps++fLangFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]+fLangFlagsDeps = [+-- See Note [Updating flag description in the User's Guide]+-- See Note [Supporting CLI completion]+  depFlagSpecOp' "th"                           LangExt.TemplateHaskell+    checkTemplateHaskellOk+    (deprecatedForExtension "TemplateHaskell"),+  depFlagSpec' "fi"                             LangExt.ForeignFunctionInterface+    (deprecatedForExtension "ForeignFunctionInterface"),+  depFlagSpec' "ffi"                            LangExt.ForeignFunctionInterface+    (deprecatedForExtension "ForeignFunctionInterface"),+  depFlagSpec' "arrows"                         LangExt.Arrows+    (deprecatedForExtension "Arrows"),+  depFlagSpec' "implicit-prelude"               LangExt.ImplicitPrelude+    (deprecatedForExtension "ImplicitPrelude"),+  depFlagSpec' "bang-patterns"                  LangExt.BangPatterns+    (deprecatedForExtension "BangPatterns"),+  depFlagSpec' "monomorphism-restriction"       LangExt.MonomorphismRestriction+    (deprecatedForExtension "MonomorphismRestriction"),+  depFlagSpec' "mono-pat-binds"                 LangExt.MonoPatBinds+    (deprecatedForExtension "MonoPatBinds"),+  depFlagSpec' "extended-default-rules"         LangExt.ExtendedDefaultRules+    (deprecatedForExtension "ExtendedDefaultRules"),+  depFlagSpec' "implicit-params"                LangExt.ImplicitParams+    (deprecatedForExtension "ImplicitParams"),+  depFlagSpec' "scoped-type-variables"          LangExt.ScopedTypeVariables+    (deprecatedForExtension "ScopedTypeVariables"),+  depFlagSpec' "allow-overlapping-instances"    LangExt.OverlappingInstances+    (deprecatedForExtension "OverlappingInstances"),+  depFlagSpec' "allow-undecidable-instances"    LangExt.UndecidableInstances+    (deprecatedForExtension "UndecidableInstances"),+  depFlagSpec' "allow-incoherent-instances"     LangExt.IncoherentInstances+    (deprecatedForExtension "IncoherentInstances")+  ]++supportedLanguages :: [String]+supportedLanguages = map (flagSpecName . snd) languageFlagsDeps++supportedLanguageOverlays :: [String]+supportedLanguageOverlays = map (flagSpecName . snd) safeHaskellFlagsDeps++supportedExtensions :: PlatformMini -> [String]+supportedExtensions targetPlatformMini = concatMap toFlagSpecNamePair xFlags+  where+    toFlagSpecNamePair flg+      -- IMPORTANT! Make sure that `ghc --supported-extensions` omits+      -- "TemplateHaskell"/"QuasiQuotes" when it's known not to work out of the+      -- box. See also GHC #11102 and #16331 for more details about+      -- the rationale+      | isAIX, flagSpecFlag flg == LangExt.TemplateHaskell  = [noName]+      | isAIX, flagSpecFlag flg == LangExt.QuasiQuotes      = [noName]+      | otherwise = [name, noName]+      where+        isAIX = platformMini_os targetPlatformMini == OSAIX+        noName = "No" ++ name+        name = flagSpecName flg++supportedLanguagesAndExtensions :: PlatformMini -> [String]+supportedLanguagesAndExtensions targetPlatformMini =+    supportedLanguages ++ supportedLanguageOverlays ++ supportedExtensions targetPlatformMini++-- | These -X<blah> flags cannot be reversed with -XNo<blah>+languageFlagsDeps :: [(Deprecation, FlagSpec Language)]+languageFlagsDeps = [+  flagSpec "Haskell98"   Haskell98,+  flagSpec "Haskell2010" Haskell2010+  ]++-- | These -X<blah> flags cannot be reversed with -XNo<blah>+-- They are used to place hard requirements on what GHC Haskell language+-- features can be used.+safeHaskellFlagsDeps :: [(Deprecation, FlagSpec SafeHaskellMode)]+safeHaskellFlagsDeps = [mkF Sf_Unsafe, mkF Sf_Trustworthy, mkF Sf_Safe]+    where mkF flag = flagSpec (show flag) flag++-- | These -X<blah> flags can all be reversed with -XNo<blah>+xFlags :: [FlagSpec LangExt.Extension]+xFlags = map snd xFlagsDeps++xFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]+xFlagsDeps = [+-- See Note [Updating flag description in the User's Guide]+-- See Note [Supporting CLI completion]+-- See Note [Adding a language extension]+-- Please keep the list of flags below sorted alphabetically+  flagSpec "AllowAmbiguousTypes"              LangExt.AllowAmbiguousTypes,+  flagSpec "AlternativeLayoutRule"            LangExt.AlternativeLayoutRule,+  flagSpec "AlternativeLayoutRuleTransitional"+                                              LangExt.AlternativeLayoutRuleTransitional,+  flagSpec "Arrows"                           LangExt.Arrows,+  depFlagSpecCond "AutoDeriveTypeable"        LangExt.AutoDeriveTypeable+    id+         ("Typeable instances are created automatically " +++                     "for all types since GHC 8.2."),+  flagSpec "BangPatterns"                     LangExt.BangPatterns,+  flagSpec "BinaryLiterals"                   LangExt.BinaryLiterals,+  flagSpec "CApiFFI"                          LangExt.CApiFFI,+  flagSpec "CPP"                              LangExt.Cpp,+  flagSpec "CUSKs"                            LangExt.CUSKs,+  flagSpec "ConstrainedClassMethods"          LangExt.ConstrainedClassMethods,+  flagSpec "ConstraintKinds"                  LangExt.ConstraintKinds,+  flagSpec "DataKinds"                        LangExt.DataKinds,+  depFlagSpecCond "DatatypeContexts"          LangExt.DatatypeContexts+    id+         ("It was widely considered a misfeature, " +++                     "and has been removed from the Haskell language."),+  flagSpec "DefaultSignatures"                LangExt.DefaultSignatures,+  flagSpec "DeriveAnyClass"                   LangExt.DeriveAnyClass,+  flagSpec "DeriveDataTypeable"               LangExt.DeriveDataTypeable,+  flagSpec "DeriveFoldable"                   LangExt.DeriveFoldable,+  flagSpec "DeriveFunctor"                    LangExt.DeriveFunctor,+  flagSpec "DeriveGeneric"                    LangExt.DeriveGeneric,+  flagSpec "DeriveLift"                       LangExt.DeriveLift,+  flagSpec "DeriveTraversable"                LangExt.DeriveTraversable,+  flagSpec "DerivingStrategies"               LangExt.DerivingStrategies,+  flagSpec "DerivingVia"                      LangExt.DerivingVia,+  flagSpec "DisambiguateRecordFields"         LangExt.DisambiguateRecordFields,+  flagSpec "DoAndIfThenElse"                  LangExt.DoAndIfThenElse,+  flagSpec "BlockArguments"                   LangExt.BlockArguments,+  depFlagSpec' "DoRec"                        LangExt.RecursiveDo+    (deprecatedForExtension "RecursiveDo"),+  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,+  flagSpec "ExtendedDefaultRules"             LangExt.ExtendedDefaultRules,+  flagSpec "FlexibleContexts"                 LangExt.FlexibleContexts,+  flagSpec "FlexibleInstances"                LangExt.FlexibleInstances,+  flagSpec "ForeignFunctionInterface"         LangExt.ForeignFunctionInterface,+  flagSpec "FunctionalDependencies"           LangExt.FunctionalDependencies,+  flagSpec "GADTSyntax"                       LangExt.GADTSyntax,+  flagSpec "GADTs"                            LangExt.GADTs,+  flagSpec "GHCForeignImportPrim"             LangExt.GHCForeignImportPrim,+  flagSpec' "GeneralizedNewtypeDeriving"      LangExt.GeneralizedNewtypeDeriving+                                              setGenDeriving,+  flagSpec' "GeneralisedNewtypeDeriving"      LangExt.GeneralizedNewtypeDeriving+                                              setGenDeriving,+  flagSpec "ImplicitParams"                   LangExt.ImplicitParams,+  flagSpec "ImplicitPrelude"                  LangExt.ImplicitPrelude,+  flagSpec "ImportQualifiedPost"              LangExt.ImportQualifiedPost,+  flagSpec "ImpredicativeTypes"               LangExt.ImpredicativeTypes,+  flagSpec' "IncoherentInstances"             LangExt.IncoherentInstances+                                              setIncoherentInsts,+  flagSpec "TypeFamilyDependencies"           LangExt.TypeFamilyDependencies,+  flagSpec "InstanceSigs"                     LangExt.InstanceSigs,+  flagSpec "ApplicativeDo"                    LangExt.ApplicativeDo,+  flagSpec "InterruptibleFFI"                 LangExt.InterruptibleFFI,+  flagSpec "JavaScriptFFI"                    LangExt.JavaScriptFFI,+  flagSpec "KindSignatures"                   LangExt.KindSignatures,+  flagSpec "LambdaCase"                       LangExt.LambdaCase,+  flagSpec "LiberalTypeSynonyms"              LangExt.LiberalTypeSynonyms,+  flagSpec "MagicHash"                        LangExt.MagicHash,+  flagSpec "MonadComprehensions"              LangExt.MonadComprehensions,+  depFlagSpec "MonadFailDesugaring"           LangExt.MonadFailDesugaring+    "MonadFailDesugaring is now the default behavior",+  flagSpec "MonoLocalBinds"                   LangExt.MonoLocalBinds,+  depFlagSpecCond "MonoPatBinds"              LangExt.MonoPatBinds+    id+         "Experimental feature now removed; has no effect",+  flagSpec "MonomorphismRestriction"          LangExt.MonomorphismRestriction,+  flagSpec "MultiParamTypeClasses"            LangExt.MultiParamTypeClasses,+  flagSpec "MultiWayIf"                       LangExt.MultiWayIf,+  flagSpec "NumericUnderscores"               LangExt.NumericUnderscores,+  flagSpec "NPlusKPatterns"                   LangExt.NPlusKPatterns,+  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"),+  flagSpec "NumDecimals"                      LangExt.NumDecimals,+  depFlagSpecOp "OverlappingInstances"        LangExt.OverlappingInstances+    setOverlappingInsts+    "instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS",+  flagSpec "OverloadedLabels"                 LangExt.OverloadedLabels,+  flagSpec "OverloadedLists"                  LangExt.OverloadedLists,+  flagSpec "OverloadedStrings"                LangExt.OverloadedStrings,+  flagSpec "PackageImports"                   LangExt.PackageImports,+  flagSpec "ParallelArrays"                   LangExt.ParallelArrays,+  flagSpec "ParallelListComp"                 LangExt.ParallelListComp,+  flagSpec "PartialTypeSignatures"            LangExt.PartialTypeSignatures,+  flagSpec "PatternGuards"                    LangExt.PatternGuards,+  depFlagSpec' "PatternSignatures"            LangExt.ScopedTypeVariables+    (deprecatedForExtension "ScopedTypeVariables"),+  flagSpec "PatternSynonyms"                  LangExt.PatternSynonyms,+  flagSpec "PolyKinds"                        LangExt.PolyKinds,+  flagSpec "PolymorphicComponents"            LangExt.RankNTypes,+  flagSpec "QuantifiedConstraints"            LangExt.QuantifiedConstraints,+  flagSpec "PostfixOperators"                 LangExt.PostfixOperators,+  flagSpec "QuasiQuotes"                      LangExt.QuasiQuotes,+  flagSpec "Rank2Types"                       LangExt.RankNTypes,+  flagSpec "RankNTypes"                       LangExt.RankNTypes,+  flagSpec "RebindableSyntax"                 LangExt.RebindableSyntax,+  depFlagSpec' "RecordPuns"                   LangExt.RecordPuns+    (deprecatedForExtension "NamedFieldPuns"),+  flagSpec "RecordWildCards"                  LangExt.RecordWildCards,+  flagSpec "RecursiveDo"                      LangExt.RecursiveDo,+  flagSpec "RelaxedLayout"                    LangExt.RelaxedLayout,+  depFlagSpecCond "RelaxedPolyRec"            LangExt.RelaxedPolyRec+    not+         "You can't turn off RelaxedPolyRec any more",+  flagSpec "RoleAnnotations"                  LangExt.RoleAnnotations,+  flagSpec "ScopedTypeVariables"              LangExt.ScopedTypeVariables,+  flagSpec "StandaloneDeriving"               LangExt.StandaloneDeriving,+  flagSpec "StarIsType"                       LangExt.StarIsType,+  flagSpec "StaticPointers"                   LangExt.StaticPointers,+  flagSpec "Strict"                           LangExt.Strict,+  flagSpec "StrictData"                       LangExt.StrictData,+  flagSpec' "TemplateHaskell"                 LangExt.TemplateHaskell+                                              checkTemplateHaskellOk,+  flagSpec "TemplateHaskellQuotes"            LangExt.TemplateHaskellQuotes,+  flagSpec "StandaloneKindSignatures"         LangExt.StandaloneKindSignatures,+  flagSpec "TraditionalRecordSyntax"          LangExt.TraditionalRecordSyntax,+  flagSpec "TransformListComp"                LangExt.TransformListComp,+  flagSpec "TupleSections"                    LangExt.TupleSections,+  flagSpec "TypeApplications"                 LangExt.TypeApplications,+  flagSpec "TypeInType"                       LangExt.TypeInType,+  flagSpec "TypeFamilies"                     LangExt.TypeFamilies,+  flagSpec "TypeOperators"                    LangExt.TypeOperators,+  flagSpec "TypeSynonymInstances"             LangExt.TypeSynonymInstances,+  flagSpec "UnboxedTuples"                    LangExt.UnboxedTuples,+  flagSpec "UnboxedSums"                      LangExt.UnboxedSums,+  flagSpec "UndecidableInstances"             LangExt.UndecidableInstances,+  flagSpec "UndecidableSuperClasses"          LangExt.UndecidableSuperClasses,+  flagSpec "UnicodeSyntax"                    LangExt.UnicodeSyntax,+  flagSpec "UnliftedFFITypes"                 LangExt.UnliftedFFITypes,+  flagSpec "UnliftedNewtypes"                 LangExt.UnliftedNewtypes,+  flagSpec "ViewPatterns"                     LangExt.ViewPatterns+  ]++defaultFlags :: Settings -> [GeneralFlag]+defaultFlags settings+-- See Note [Updating flag description in the User's Guide]+  = [ Opt_AutoLinkPackages,+      Opt_DiagnosticsShowCaret,+      Opt_EmbedManifest,+      Opt_FlatCache,+      Opt_GenManifest,+      Opt_GhciHistory,+      Opt_GhciSandbox,+      Opt_HelpfulErrors,+      Opt_KeepHiFiles,+      Opt_KeepOFiles,+      Opt_OmitYields,+      Opt_PrintBindContents,+      Opt_ProfCountEntries,+      Opt_RPath,+      Opt_SharedImplib,+      Opt_SimplPreInlining,+      Opt_VersionMacros+    ]++    ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]+             -- The default -O0 options++    ++ default_PIC platform++    ++ concatMap (wayGeneralFlags platform) (defaultWays settings)+    ++ validHoleFitDefaults++    where platform = sTargetPlatform settings++-- | These are the default settings for the display and sorting of valid hole+--  fits in typed-hole error messages. See Note [Valid hole fits include ...]+ -- in the TcHoleErrors module.+validHoleFitDefaults :: [GeneralFlag]+validHoleFitDefaults+  =  [ Opt_ShowTypeAppOfHoleFits+     , Opt_ShowTypeOfHoleFits+     , Opt_ShowProvOfHoleFits+     , Opt_ShowMatchesOfHoleFits+     , Opt_ShowValidHoleFits+     , Opt_SortValidHoleFits+     , Opt_SortBySizeHoleFits+     , Opt_ShowHoleConstraints ]+++validHoleFitsImpliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]+validHoleFitsImpliedGFlags+  = [ (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowTypeAppOfHoleFits)+    , (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowTypeAppVarsOfHoleFits)+    , (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowDocsOfHoleFits)+    , (Opt_ShowTypeAppVarsOfHoleFits, turnOff, Opt_ShowTypeAppOfHoleFits)+    , (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowProvOfHoleFits) ]++default_PIC :: Platform -> [GeneralFlag]+default_PIC platform =+  case (platformOS platform, platformArch platform) of+    (OSDarwin, ArchX86_64) -> [Opt_PIC]+    (OSOpenBSD, ArchX86_64) -> [Opt_PIC] -- Due to PIE support in+                                         -- OpenBSD since 5.3 release+                                         -- (1 May 2013) we need to+                                         -- always generate PIC. See+                                         -- #10597 for more+                                         -- information.+    _                      -> []++-- General flags that are switched on/off when other general flags are switched+-- on+impliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]+impliedGFlags = [(Opt_DeferTypeErrors, turnOn, Opt_DeferTypedHoles)+                ,(Opt_DeferTypeErrors, turnOn, Opt_DeferOutOfScopeVariables)+                ,(Opt_Strictness, turnOn, Opt_WorkerWrapper)+                ] ++ validHoleFitsImpliedGFlags++-- General flags that are switched on/off when other general flags are switched+-- off+impliedOffGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]+impliedOffGFlags = [(Opt_Strictness, turnOff, Opt_WorkerWrapper)]++impliedXFlags :: [(LangExt.Extension, TurnOnFlag, LangExt.Extension)]+impliedXFlags+-- See Note [Updating flag description in the User's Guide]+  = [ (LangExt.RankNTypes,                turnOn, LangExt.ExplicitForAll)+    , (LangExt.QuantifiedConstraints,     turnOn, LangExt.ExplicitForAll)+    , (LangExt.ScopedTypeVariables,       turnOn, LangExt.ExplicitForAll)+    , (LangExt.LiberalTypeSynonyms,       turnOn, LangExt.ExplicitForAll)+    , (LangExt.ExistentialQuantification, turnOn, LangExt.ExplicitForAll)+    , (LangExt.FlexibleInstances,         turnOn, LangExt.TypeSynonymInstances)+    , (LangExt.FunctionalDependencies,    turnOn, LangExt.MultiParamTypeClasses)+    , (LangExt.MultiParamTypeClasses,     turnOn, LangExt.ConstrainedClassMethods)  -- c.f. #7854+    , (LangExt.TypeFamilyDependencies,    turnOn, LangExt.TypeFamilies)++    , (LangExt.RebindableSyntax, turnOff, LangExt.ImplicitPrelude)      -- NB: turn off!++    , (LangExt.DerivingVia, turnOn, LangExt.DerivingStrategies)++    , (LangExt.GADTs,            turnOn, LangExt.GADTSyntax)+    , (LangExt.GADTs,            turnOn, LangExt.MonoLocalBinds)+    , (LangExt.TypeFamilies,     turnOn, LangExt.MonoLocalBinds)++    , (LangExt.TypeFamilies,     turnOn, LangExt.KindSignatures)  -- Type families use kind signatures+    , (LangExt.PolyKinds,        turnOn, LangExt.KindSignatures)  -- Ditto polymorphic kinds++    -- TypeInType is now just a synonym for a couple of other extensions.+    , (LangExt.TypeInType,       turnOn, LangExt.DataKinds)+    , (LangExt.TypeInType,       turnOn, LangExt.PolyKinds)+    , (LangExt.TypeInType,       turnOn, LangExt.KindSignatures)++    -- Standalone kind signatures are a replacement for CUSKs.+    , (LangExt.StandaloneKindSignatures, turnOff, LangExt.CUSKs)++    -- AutoDeriveTypeable is not very useful without DeriveDataTypeable+    , (LangExt.AutoDeriveTypeable, turnOn, LangExt.DeriveDataTypeable)++    -- We turn this on so that we can export associated type+    -- type synonyms in subordinates (e.g. MyClass(type AssocType))+    , (LangExt.TypeFamilies,     turnOn, LangExt.ExplicitNamespaces)+    , (LangExt.TypeOperators, turnOn, LangExt.ExplicitNamespaces)++    , (LangExt.ImpredicativeTypes,  turnOn, LangExt.RankNTypes)++        -- Record wild-cards implies field disambiguation+        -- Otherwise if you write (C {..}) you may well get+        -- stuff like " 'a' not in scope ", which is a bit silly+        -- if the compiler has just filled in field 'a' of constructor 'C'+    , (LangExt.RecordWildCards,     turnOn, LangExt.DisambiguateRecordFields)++    , (LangExt.ParallelArrays, turnOn, LangExt.ParallelListComp)++    , (LangExt.JavaScriptFFI, turnOn, LangExt.InterruptibleFFI)++    , (LangExt.DeriveTraversable, turnOn, LangExt.DeriveFunctor)+    , (LangExt.DeriveTraversable, turnOn, LangExt.DeriveFoldable)++    -- Duplicate record fields require field disambiguation+    , (LangExt.DuplicateRecordFields, turnOn, LangExt.DisambiguateRecordFields)++    , (LangExt.TemplateHaskell, turnOn, LangExt.TemplateHaskellQuotes)+    , (LangExt.Strict, turnOn, LangExt.StrictData)+  ]++-- Note [When is StarIsType enabled]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- The StarIsType extension determines whether to treat '*' as a regular type+-- operator or as a synonym for 'Data.Kind.Type'. Many existing pre-TypeInType+-- programs expect '*' to be synonymous with 'Type', so by default StarIsType is+-- enabled.+--+-- Programs that use TypeOperators might expect to repurpose '*' for+-- multiplication or another binary operation, but making TypeOperators imply+-- NoStarIsType caused too much breakage on Hackage.+--++-- Note [Documenting optimisation flags]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- If you change the list of flags enabled for particular optimisation levels+-- please remember to update the User's Guide. The relevant file is:+--+--   docs/users_guide/using-optimisation.rst+--+-- Make sure to note whether a flag is implied by -O0, -O or -O2.++optLevelFlags :: [([Int], GeneralFlag)]+-- Default settings of flags, before any command-line overrides+optLevelFlags -- see Note [Documenting optimisation flags]+  = [ ([0,1,2], Opt_DoLambdaEtaExpansion)+    , ([0,1,2], Opt_DoEtaReduction)       -- See Note [Eta-reduction in -O0]+    , ([0,1,2], Opt_DmdTxDictSel)+    , ([0,1,2], Opt_LlvmTBAA)++    , ([0],     Opt_IgnoreInterfacePragmas)+    , ([0],     Opt_OmitInterfacePragmas)++    , ([1,2],   Opt_CallArity)+    , ([1,2],   Opt_Exitification)+    , ([1,2],   Opt_CaseMerge)+    , ([1,2],   Opt_CaseFolding)+    , ([1,2],   Opt_CmmElimCommonBlocks)+    , ([2],     Opt_AsmShortcutting)+    , ([1,2],   Opt_CmmSink)+    , ([1,2],   Opt_CSE)+    , ([1,2],   Opt_StgCSE)+    , ([2],     Opt_StgLiftLams)++    , ([1,2],   Opt_EnableRewriteRules)+          -- Off for -O0.   Otherwise we desugar list literals+          -- to 'build' but don't run the simplifier passes that+          -- would rewrite them back to cons cells!  This seems+          -- silly, and matters for the GHCi debugger.++    , ([1,2],   Opt_FloatIn)+    , ([1,2],   Opt_FullLaziness)+    , ([1,2],   Opt_IgnoreAsserts)+    , ([1,2],   Opt_Loopification)+    , ([1,2],   Opt_CfgBlocklayout)      -- Experimental++    , ([1,2],   Opt_Specialise)+    , ([1,2],   Opt_CrossModuleSpecialise)+    , ([1,2],   Opt_Strictness)+    , ([1,2],   Opt_UnboxSmallStrictFields)+    , ([1,2],   Opt_CprAnal)+    , ([1,2],   Opt_WorkerWrapper)+    , ([1,2],   Opt_SolveConstantDicts)+    , ([1,2],   Opt_NumConstantFolding)++    , ([2],     Opt_LiberateCase)+    , ([2],     Opt_SpecConstr)+--  , ([2],     Opt_RegsGraph)+--   RegsGraph suffers performance regression. See #7679+--  , ([2],     Opt_StaticArgumentTransformation)+--   Static Argument Transformation needs investigation. See #9374+    ]+++-- -----------------------------------------------------------------------------+-- Standard sets of warning options++-- Note [Documenting warning flags]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- If you change the list of warning enabled by default+-- please remember to update the User's Guide. The relevant file is:+--+--  docs/users_guide/using-warnings.rst++-- | Warning groups.+--+-- As all warnings are in the Weverything set, it is ignored when+-- displaying to the user which group a warning is in.+warningGroups :: [(String, [WarningFlag])]+warningGroups =+    [ ("compat",       minusWcompatOpts)+    , ("unused-binds", unusedBindsFlags)+    , ("default",      standardWarnings)+    , ("extra",        minusWOpts)+    , ("all",          minusWallOpts)+    , ("everything",   minusWeverythingOpts)+    ]++-- | Warning group hierarchies, where there is an explicit inclusion+-- relation.+--+-- Each inner list is a hierarchy of warning groups, ordered from+-- smallest to largest, where each group is a superset of the one+-- before it.+--+-- Separating this from 'warningGroups' allows for multiple+-- hierarchies with no inherent relation to be defined.+--+-- The special-case Weverything group is not included.+warningHierarchies :: [[String]]+warningHierarchies = hierarchies ++ map (:[]) rest+  where+    hierarchies = [["default", "extra", "all"]]+    rest = filter (`notElem` "everything" : concat hierarchies) $+           map fst warningGroups++-- | Find the smallest group in every hierarchy which a warning+-- belongs to, excluding Weverything.+smallestGroups :: WarningFlag -> [String]+smallestGroups flag = mapMaybe go warningHierarchies where+    -- Because each hierarchy is arranged from smallest to largest,+    -- the first group we find in a hierarchy which contains the flag+    -- is the smallest.+    go (group:rest) = fromMaybe (go rest) $ do+        flags <- lookup group warningGroups+        guard (flag `elem` flags)+        pure (Just group)+    go [] = Nothing++-- | Warnings enabled unless specified otherwise+standardWarnings :: [WarningFlag]+standardWarnings -- see Note [Documenting warning flags]+    = [ Opt_WarnOverlappingPatterns,+        Opt_WarnWarningsDeprecations,+        Opt_WarnDeprecatedFlags,+        Opt_WarnDeferredTypeErrors,+        Opt_WarnTypedHoles,+        Opt_WarnDeferredOutOfScopeVariables,+        Opt_WarnPartialTypeSignatures,+        Opt_WarnUnrecognisedPragmas,+        Opt_WarnDuplicateExports,+        Opt_WarnDerivingDefaults,+        Opt_WarnOverflowedLiterals,+        Opt_WarnEmptyEnumerations,+        Opt_WarnMissingFields,+        Opt_WarnMissingMethods,+        Opt_WarnWrongDoBind,+        Opt_WarnUnsupportedCallingConventions,+        Opt_WarnDodgyForeignImports,+        Opt_WarnInlineRuleShadowing,+        Opt_WarnAlternativeLayoutRuleTransitional,+        Opt_WarnUnsupportedLlvmVersion,+        Opt_WarnMissedExtraSharedLib,+        Opt_WarnTabs,+        Opt_WarnUnrecognisedWarningFlags,+        Opt_WarnSimplifiableClassConstraints,+        Opt_WarnStarBinder,+        Opt_WarnInaccessibleCode,+        Opt_WarnSpaceAfterBang+      ]++-- | Things you get with -W+minusWOpts :: [WarningFlag]+minusWOpts+    = standardWarnings +++      [ Opt_WarnUnusedTopBinds,+        Opt_WarnUnusedLocalBinds,+        Opt_WarnUnusedPatternBinds,+        Opt_WarnUnusedMatches,+        Opt_WarnUnusedForalls,+        Opt_WarnUnusedImports,+        Opt_WarnIncompletePatterns,+        Opt_WarnDodgyExports,+        Opt_WarnDodgyImports,+        Opt_WarnUnbangedStrictPatterns+      ]++-- | Things you get with -Wall+minusWallOpts :: [WarningFlag]+minusWallOpts+    = minusWOpts +++      [ Opt_WarnTypeDefaults,+        Opt_WarnNameShadowing,+        Opt_WarnMissingSignatures,+        Opt_WarnHiShadows,+        Opt_WarnOrphans,+        Opt_WarnUnusedDoBind,+        Opt_WarnTrustworthySafe,+        Opt_WarnUntickedPromotedConstructors,+        Opt_WarnMissingPatternSynonymSignatures,+        Opt_WarnUnusedRecordWildcards,+        Opt_WarnRedundantRecordWildcards,+        Opt_WarnStarIsType+      ]++-- | Things you get with -Weverything, i.e. *all* known warnings flags+minusWeverythingOpts :: [WarningFlag]+minusWeverythingOpts = [ toEnum 0 .. ]++-- | Things you get with -Wcompat.+--+-- This is intended to group together warnings that will be enabled by default+-- at some point in the future, so that library authors eager to make their+-- code future compatible to fix issues before they even generate warnings.+minusWcompatOpts :: [WarningFlag]+minusWcompatOpts+    = [ Opt_WarnSemigroup+      , Opt_WarnNonCanonicalMonoidInstances+      , Opt_WarnStarIsType+      , Opt_WarnCompatUnqualifiedImports+      ]++enableUnusedBinds :: DynP ()+enableUnusedBinds = mapM_ setWarningFlag unusedBindsFlags++disableUnusedBinds :: DynP ()+disableUnusedBinds = mapM_ unSetWarningFlag unusedBindsFlags++-- Things you get with -Wunused-binds+unusedBindsFlags :: [WarningFlag]+unusedBindsFlags = [ Opt_WarnUnusedTopBinds+                   , Opt_WarnUnusedLocalBinds+                   , Opt_WarnUnusedPatternBinds+                   ]++enableGlasgowExts :: DynP ()+enableGlasgowExts = do setGeneralFlag Opt_PrintExplicitForalls+                       mapM_ setExtensionFlag glasgowExtsFlags++disableGlasgowExts :: DynP ()+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+           , LangExt.DeriveDataTypeable+           , LangExt.DeriveFoldable+           , LangExt.DeriveFunctor+           , LangExt.DeriveGeneric+           , LangExt.DeriveTraversable+           , LangExt.EmptyDataDecls+           , LangExt.ExistentialQuantification+           , LangExt.ExplicitNamespaces+           , LangExt.FlexibleContexts+           , LangExt.FlexibleInstances+           , LangExt.ForeignFunctionInterface+           , LangExt.FunctionalDependencies+           , LangExt.GeneralizedNewtypeDeriving+           , LangExt.ImplicitParams+           , LangExt.KindSignatures+           , LangExt.LiberalTypeSynonyms+           , LangExt.MagicHash+           , LangExt.MultiParamTypeClasses+           , LangExt.ParallelListComp+           , LangExt.PatternGuards+           , LangExt.PostfixOperators+           , LangExt.RankNTypes+           , LangExt.RecursiveDo+           , LangExt.ScopedTypeVariables+           , LangExt.StandaloneDeriving+           , LangExt.TypeOperators+           , LangExt.TypeSynonymInstances+           , LangExt.UnboxedTuples+           , LangExt.UnicodeSyntax+           , LangExt.UnliftedFFITypes ]++foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt++-- | Was the runtime system built with profiling enabled?+rtsIsProfiled :: Bool+rtsIsProfiled = unsafeDupablePerformIO rtsIsProfiledIO /= 0++-- Consult the RTS to find whether GHC itself has been built with+-- dynamic linking.  This can't be statically known at compile-time,+-- because we build both the static and dynamic versions together with+-- -dynamic-too.+foreign import ccall unsafe "rts_isDynamic" rtsIsDynamicIO :: IO CInt++dynamicGhc :: Bool+dynamicGhc = unsafeDupablePerformIO rtsIsDynamicIO /= 0++setWarnSafe :: Bool -> DynP ()+setWarnSafe True  = getCurLoc >>= \l -> upd (\d -> d { warnSafeOnLoc = l })+setWarnSafe False = return ()++setWarnUnsafe :: Bool -> DynP ()+setWarnUnsafe True  = getCurLoc >>= \l -> upd (\d -> d { warnUnsafeOnLoc = l })+setWarnUnsafe False = return ()++setPackageTrust :: DynP ()+setPackageTrust = do+    setGeneralFlag Opt_PackageTrust+    l <- getCurLoc+    upd $ \d -> d { pkgTrustOnLoc = l }++setGenDeriving :: TurnOnFlag -> DynP ()+setGenDeriving True  = getCurLoc >>= \l -> upd (\d -> d { newDerivOnLoc = l })+setGenDeriving False = return ()++setOverlappingInsts :: TurnOnFlag -> DynP ()+setOverlappingInsts False = return ()+setOverlappingInsts True = do+  l <- getCurLoc+  upd (\d -> d { overlapInstLoc = l })++setIncoherentInsts :: TurnOnFlag -> DynP ()+setIncoherentInsts False = return ()+setIncoherentInsts True = do+  l <- getCurLoc+  upd (\d -> d { incoherentOnLoc = l })++checkTemplateHaskellOk :: TurnOnFlag -> DynP ()+checkTemplateHaskellOk _turn_on+  = getCurLoc >>= \l -> upd (\d -> d { thOnLoc = l })++{- **********************************************************************+%*                                                                      *+                DynFlags constructors+%*                                                                      *+%********************************************************************* -}++type DynP = EwM (CmdLineP DynFlags)++upd :: (DynFlags -> DynFlags) -> DynP ()+upd f = liftEwM (do dflags <- getCmdLineState+                    putCmdLineState $! f dflags)++updM :: (DynFlags -> DynP DynFlags) -> DynP ()+updM f = do dflags <- liftEwM getCmdLineState+            dflags' <- f dflags+            liftEwM $ putCmdLineState $! dflags'++--------------- Constructor functions for OptKind -----------------+noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)+noArg fn = NoArg (upd fn)++noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)+noArgM fn = NoArg (updM fn)++hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)+hasArg fn = HasArg (upd . fn)++sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)+sepArg fn = SepArg (upd . fn)++intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)+intSuffix fn = IntSuffix (\n -> upd (fn n))++intSuffixM :: (Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)+intSuffixM fn = IntSuffix (\n -> updM (fn n))++floatSuffix :: (Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)+floatSuffix fn = FloatSuffix (\n -> upd (fn n))++optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)+              -> OptKind (CmdLineP DynFlags)+optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))++setDumpFlag :: DumpFlag -> OptKind (CmdLineP DynFlags)+setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)++--------------------------+addWay :: Way -> DynP ()+addWay w = upd (addWay' w)++addWay' :: Way -> DynFlags -> DynFlags+addWay' w dflags0 = let platform = targetPlatform dflags0+                        dflags1 = dflags0 { ways = w : ways dflags0 }+                        dflags2 = foldr setGeneralFlag' dflags1+                                        (wayGeneralFlags platform w)+                        dflags3 = foldr unSetGeneralFlag' dflags2+                                        (wayUnsetGeneralFlags platform w)+                    in dflags3++removeWayDyn :: DynP ()+removeWayDyn = upd (\dfs -> dfs { ways = filter (WayDyn /=) (ways dfs) })++--------------------------+setGeneralFlag, unSetGeneralFlag :: GeneralFlag -> DynP ()+setGeneralFlag   f = upd (setGeneralFlag' f)+unSetGeneralFlag f = upd (unSetGeneralFlag' f)++setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags+setGeneralFlag' f dflags = foldr ($) (gopt_set dflags f) deps+  where+    deps = [ if turn_on then setGeneralFlag'   d+                        else unSetGeneralFlag' d+           | (f', turn_on, d) <- impliedGFlags, f' == f ]+        -- When you set f, set the ones it implies+        -- NB: use setGeneralFlag recursively, in case the implied flags+        --     implies further flags++unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags+unSetGeneralFlag' f dflags = foldr ($) (gopt_unset dflags f) deps+  where+    deps = [ if turn_on then setGeneralFlag' d+                        else unSetGeneralFlag' d+           | (f', turn_on, d) <- impliedOffGFlags, f' == f ]+   -- In general, when you un-set f, we don't un-set the things it implies.+   -- There are however some exceptions, e.g., -fno-strictness implies+   -- -fno-worker-wrapper.+   --+   -- NB: use unSetGeneralFlag' recursively, in case the implied off flags+   --     imply further flags.++--------------------------+setWarningFlag, unSetWarningFlag :: WarningFlag -> DynP ()+setWarningFlag   f = upd (\dfs -> wopt_set dfs f)+unSetWarningFlag f = upd (\dfs -> wopt_unset dfs f)++setFatalWarningFlag, unSetFatalWarningFlag :: WarningFlag -> DynP ()+setFatalWarningFlag   f = upd (\dfs -> wopt_set_fatal dfs f)+unSetFatalWarningFlag f = upd (\dfs -> wopt_unset_fatal dfs f)++setWErrorFlag :: WarningFlag -> DynP ()+setWErrorFlag flag =+  do { setWarningFlag flag+     ; setFatalWarningFlag flag }++--------------------------+setExtensionFlag, unSetExtensionFlag :: LangExt.Extension -> DynP ()+setExtensionFlag f = upd (setExtensionFlag' f)+unSetExtensionFlag f = upd (unSetExtensionFlag' f)++setExtensionFlag', unSetExtensionFlag' :: LangExt.Extension -> DynFlags -> DynFlags+setExtensionFlag' f dflags = foldr ($) (xopt_set dflags f) deps+  where+    deps = [ if turn_on then setExtensionFlag'   d+                        else unSetExtensionFlag' d+           | (f', turn_on, d) <- impliedXFlags, f' == f ]+        -- When you set f, set the ones it implies+        -- NB: use setExtensionFlag recursively, in case the implied flags+        --     implies further flags++unSetExtensionFlag' f dflags = xopt_unset dflags f+   -- When you un-set f, however, we don't un-set the things it implies+   --      (except for -fno-glasgow-exts, which is treated specially)++--------------------------+alterFileSettings :: (FileSettings -> FileSettings) -> DynFlags -> DynFlags+alterFileSettings f dynFlags = dynFlags { fileSettings = f (fileSettings dynFlags) }++alterToolSettings :: (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags+alterToolSettings f dynFlags = dynFlags { toolSettings = f (toolSettings dynFlags) }++--------------------------+setDumpFlag' :: DumpFlag -> DynP ()+setDumpFlag' dump_flag+  = do upd (\dfs -> dopt_set dfs dump_flag)+       when want_recomp forceRecompile+    where -- Certain dumpy-things are really interested in what's going+          -- on during recompilation checking, so in those cases we+          -- don't want to turn it off.+          want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,+                                             Opt_D_dump_hi_diffs,+                                             Opt_D_no_debug_output]++forceRecompile :: DynP ()+-- Whenever we -ddump, force recompilation (by switching off the+-- recompilation checker), else you don't see the dump! However,+-- don't switch it off in --make mode, else *everything* gets+-- recompiled which probably isn't what you want+forceRecompile = do dfs <- liftEwM getCmdLineState+                    when (force_recomp dfs) (setGeneralFlag Opt_ForceRecomp)+        where+          force_recomp dfs = isOneShot (ghcMode dfs)+++setVerboseCore2Core :: DynP ()+setVerboseCore2Core = setDumpFlag' Opt_D_verbose_core2core++setVerbosity :: Maybe Int -> DynP ()+setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })++setDebugLevel :: Maybe Int -> DynP ()+setDebugLevel mb_n = upd (\dfs -> dfs{ debugLevel = mb_n `orElse` 2 })++data PkgDbRef+  = GlobalPkgDb+  | UserPkgDb+  | PkgDbPath FilePath+  deriving Eq++addPkgDbRef :: PkgDbRef -> DynP ()+addPkgDbRef p = upd $ \s ->+  s { packageDBFlags = PackageDB p : packageDBFlags s }++removeUserPkgDb :: DynP ()+removeUserPkgDb = upd $ \s ->+  s { packageDBFlags = NoUserPackageDB : packageDBFlags s }++removeGlobalPkgDb :: DynP ()+removeGlobalPkgDb = upd $ \s ->+ s { packageDBFlags = NoGlobalPackageDB : packageDBFlags s }++clearPkgDb :: DynP ()+clearPkgDb = upd $ \s ->+  s { packageDBFlags = ClearPackageDBs : packageDBFlags s }++parsePackageFlag :: String                 -- the flag+                 -> ReadP PackageArg       -- type of argument+                 -> String                 -- string to parse+                 -> PackageFlag+parsePackageFlag flag arg_parse str+ = case filter ((=="").snd) (readP_to_S parse str) of+    [(r, "")] -> r+    _ -> throwGhcException $ CmdLineError ("Can't parse package flag: " ++ str)+  where doc = flag ++ " " ++ str+        parse = do+            pkg_arg <- tok arg_parse+            let mk_expose = ExposePackage doc pkg_arg+            ( do _ <- tok $ string "with"+                 fmap (mk_expose . ModRenaming True) parseRns+             <++ fmap (mk_expose . ModRenaming False) parseRns+             <++ return (mk_expose (ModRenaming True [])))+        parseRns = do _ <- tok $ R.char '('+                      rns <- tok $ sepBy parseItem (tok $ R.char ',')+                      _ <- tok $ R.char ')'+                      return rns+        parseItem = do+            orig <- tok $ parseModuleName+            (do _ <- tok $ string "as"+                new <- tok $ parseModuleName+                return (orig, new)+              ++++             return (orig, orig))+        tok m = m >>= \x -> skipSpaces >> return x++exposePackage, exposePackageId, hidePackage,+        exposePluginPackage, exposePluginPackageId,+        ignorePackage,+        trustPackage, distrustPackage :: String -> DynP ()+exposePackage p = upd (exposePackage' p)+exposePackageId p =+  upd (\s -> s{ packageFlags =+    parsePackageFlag "-package-id" parseUnitIdArg p : packageFlags s })+exposePluginPackage p =+  upd (\s -> s{ pluginPackageFlags =+    parsePackageFlag "-plugin-package" parsePackageArg p : pluginPackageFlags s })+exposePluginPackageId p =+  upd (\s -> s{ pluginPackageFlags =+    parsePackageFlag "-plugin-package-id" parseUnitIdArg p : pluginPackageFlags s })+hidePackage p =+  upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })+ignorePackage p =+  upd (\s -> s{ ignorePackageFlags = IgnorePackage p : ignorePackageFlags s })++trustPackage p = exposePackage p >> -- both trust and distrust also expose a package+  upd (\s -> s{ trustFlags = TrustPackage p : trustFlags s })+distrustPackage p = exposePackage p >>+  upd (\s -> s{ trustFlags = DistrustPackage p : trustFlags s })++exposePackage' :: String -> DynFlags -> DynFlags+exposePackage' p dflags+    = dflags { packageFlags =+            parsePackageFlag "-package" parsePackageArg p : packageFlags dflags }++parsePackageArg :: ReadP PackageArg+parsePackageArg =+    fmap PackageArg (munch1 (\c -> isAlphaNum c || c `elem` ":-_."))++parseUnitIdArg :: ReadP PackageArg+parseUnitIdArg =+    fmap UnitIdArg parseUnitId++setUnitId :: String -> DynFlags -> DynFlags+setUnitId p d = d { thisInstalledUnitId = stringToInstalledUnitId p }++-- | Given a 'ModuleName' of a signature in the home library, find+-- out how it is instantiated.  E.g., the canonical form of+-- A in @p[A=q[]:A]@ is @q[]:A@.+canonicalizeHomeModule :: DynFlags -> ModuleName -> Module+canonicalizeHomeModule dflags mod_name =+    case lookup mod_name (thisUnitIdInsts dflags) of+        Nothing  -> mkModule (thisPackage dflags) mod_name+        Just mod -> mod++canonicalizeModuleIfHome :: DynFlags -> Module -> Module+canonicalizeModuleIfHome dflags mod+    = if thisPackage dflags == moduleUnitId mod+                      then canonicalizeHomeModule dflags (moduleName mod)+                      else mod++-- If we're linking a binary, then only targets that produce object+-- code are allowed (requests for other target types are ignored).+setTarget :: HscTarget -> DynP ()+setTarget l = upd $ \ dfs ->+  if ghcLink dfs /= LinkBinary || isObjectTarget l+  then dfs{ hscTarget = l }+  else dfs++-- Changes the target only if we're compiling object code.  This is+-- used by -fasm and -fllvm, which switch from one to the other, but+-- not from bytecode to object-code.  The idea is that -fasm/-fllvm+-- can be safely used in an OPTIONS_GHC pragma.+setObjTarget :: HscTarget -> DynP ()+setObjTarget l = updM set+  where+   set dflags+     | isObjectTarget (hscTarget dflags)+       = return $ dflags { hscTarget = l }+     | otherwise = return dflags++setOptLevel :: Int -> DynFlags -> DynP DynFlags+setOptLevel n dflags = return (updOptLevel n dflags)++checkOptLevel :: Int -> DynFlags -> Either String DynFlags+checkOptLevel n dflags+   | hscTarget dflags == HscInterpreted && n > 0+     = Left "-O conflicts with --interactive; -O ignored."+   | otherwise+     = Right dflags++setMainIs :: String -> DynP ()+setMainIs arg+  | not (null main_fn) && isLower (head main_fn)+     -- The arg looked like "Foo.Bar.baz"+  = upd $ \d -> d { mainFunIs = Just main_fn,+                   mainModIs = mkModule mainUnitId (mkModuleName main_mod) }++  | isUpper (head arg)  -- The arg looked like "Foo" or "Foo.Bar"+  = upd $ \d -> d { mainModIs = mkModule mainUnitId (mkModuleName arg) }++  | otherwise                   -- The arg looked like "baz"+  = upd $ \d -> d { mainFunIs = Just arg }+  where+    (main_mod, main_fn) = splitLongestPrefix arg (== '.')++addLdInputs :: Option -> DynFlags -> DynFlags+addLdInputs p dflags = dflags{ldInputs = ldInputs dflags ++ [p]}++-- -----------------------------------------------------------------------------+-- Load dynflags from environment files.++setFlagsFromEnvFile :: FilePath -> String -> DynP ()+setFlagsFromEnvFile envfile content = do+  setGeneralFlag Opt_HideAllPackages+  parseEnvFile envfile content++parseEnvFile :: FilePath -> String -> DynP ()+parseEnvFile envfile = mapM_ parseEntry . lines+  where+    parseEntry str = case words str of+      ("package-db": _)     -> addPkgDbRef (PkgDbPath (envdir </> db))+        -- relative package dbs are interpreted relative to the env file+        where envdir = takeDirectory envfile+              db     = drop 11 str+      ["clear-package-db"]  -> clearPkgDb+      ["global-package-db"] -> addPkgDbRef GlobalPkgDb+      ["user-package-db"]   -> addPkgDbRef UserPkgDb+      ["package-id", pkgid] -> exposePackageId pkgid+      (('-':'-':_):_)       -> return () -- comments+      -- and the original syntax introduced in 7.10:+      [pkgid]               -> exposePackageId pkgid+      []                    -> return ()+      _                     -> throwGhcException $ CmdLineError $+                                    "Can't parse environment file entry: "+                                 ++ envfile ++ ": " ++ str+++-----------------------------------------------------------------------------+-- Paths & Libraries++addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()++-- -i on its own deletes the import paths+addImportPath "" = upd (\s -> s{importPaths = []})+addImportPath p  = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})++addLibraryPath p =+  upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})++addIncludePath p =+  upd (\s -> s{includePaths =+                  addGlobalInclude (includePaths s) (splitPathList p)})++addFrameworkPath p =+  upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})++#if !defined(mingw32_HOST_OS)+split_marker :: Char+split_marker = ':'   -- not configurable (ToDo)+#endif++splitPathList :: String -> [String]+splitPathList s = filter notNull (splitUp s)+                -- empty paths are ignored: there might be a trailing+                -- ':' in the initial list, for example.  Empty paths can+                -- cause confusion when they are translated into -I options+                -- for passing to gcc.+  where+#if !defined(mingw32_HOST_OS)+    splitUp xs = split split_marker xs+#else+     -- Windows: 'hybrid' support for DOS-style paths in directory lists.+     --+     -- That is, if "foo:bar:baz" is used, this interpreted as+     -- consisting of three entries, 'foo', 'bar', 'baz'.+     -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted+     -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"+     --+     -- Notice that no attempt is made to fully replace the 'standard'+     -- split marker ':' with the Windows / DOS one, ';'. The reason being+     -- that this will cause too much breakage for users & ':' will+     -- work fine even with DOS paths, if you're not insisting on being silly.+     -- So, use either.+    splitUp []             = []+    splitUp (x:':':div:xs) | div `elem` dir_markers+                           = ((x:':':div:p): splitUp rs)+                           where+                              (p,rs) = findNextPath xs+          -- we used to check for existence of the path here, but that+          -- required the IO monad to be threaded through the command-line+          -- parser which is quite inconvenient.  The+    splitUp xs = cons p (splitUp rs)+               where+                 (p,rs) = findNextPath xs++                 cons "" xs = xs+                 cons x  xs = x:xs++    -- will be called either when we've consumed nought or the+    -- "<Drive>:/" part of a DOS path, so splitting is just a Q of+    -- finding the next split marker.+    findNextPath xs =+        case break (`elem` split_markers) xs of+           (p, _:ds) -> (p, ds)+           (p, xs)   -> (p, xs)++    split_markers :: [Char]+    split_markers = [':', ';']++    dir_markers :: [Char]+    dir_markers = ['/', '\\']+#endif++-- -----------------------------------------------------------------------------+-- tmpDir, where we store temporary files.++setTmpDir :: FilePath -> DynFlags -> DynFlags+setTmpDir dir = alterFileSettings $ \s -> s { fileSettings_tmpDir = normalise dir }+  -- we used to fix /cygdrive/c/.. on Windows, but this doesn't+  -- seem necessary now --SDM 7/2/2008++-----------------------------------------------------------------------------+-- RTS opts++setRtsOpts :: String -> DynP ()+setRtsOpts arg  = upd $ \ d -> d {rtsOpts = Just arg}++setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()+setRtsOptsEnabled arg  = upd $ \ d -> d {rtsOptsEnabled = arg}++-----------------------------------------------------------------------------+-- Hpc stuff++setOptHpcDir :: String -> DynP ()+setOptHpcDir arg  = upd $ \ d -> d {hpcDir = arg}++-----------------------------------------------------------------------------+-- Via-C compilation stuff++-- There are some options that we need to pass to gcc when compiling+-- Haskell code via C, but are only supported by recent versions of+-- gcc.  The configure script decides which of these options we need,+-- and puts them in the "settings" file in $topdir. The advantage of+-- having these in a separate file is that the file can be created at+-- install-time depending on the available gcc version, and even+-- re-generated later if gcc is upgraded.+--+-- The options below are not dependent on the version of gcc, only the+-- platform.++picCCOpts :: DynFlags -> [String]+picCCOpts dflags = pieOpts ++ picOpts+  where+    picOpts =+      case platformOS (targetPlatform dflags) of+      OSDarwin+          -- Apple prefers to do things the other way round.+          -- PIC is on by default.+          -- -mdynamic-no-pic:+          --     Turn off PIC code generation.+          -- -fno-common:+          --     Don't generate "common" symbols - these are unwanted+          --     in dynamic libraries.++       | gopt Opt_PIC dflags -> ["-fno-common", "-U__PIC__", "-D__PIC__"]+       | otherwise           -> ["-mdynamic-no-pic"]+      OSMinGW32 -- no -fPIC for Windows+       | gopt Opt_PIC dflags -> ["-U__PIC__", "-D__PIC__"]+       | otherwise           -> []+      _+      -- we need -fPIC for C files when we are compiling with -dynamic,+      -- otherwise things like stub.c files don't get compiled+      -- correctly.  They need to reference data in the Haskell+      -- objects, but can't without -fPIC.  See+      -- https://gitlab.haskell.org/ghc/ghc/wikis/commentary/position-independent-code+       | gopt Opt_PIC dflags || WayDyn `elem` ways dflags ->+          ["-fPIC", "-U__PIC__", "-D__PIC__"]+      -- gcc may be configured to have PIC on by default, let's be+      -- explicit here, see #15847+       | otherwise -> ["-fno-PIC"]++    pieOpts+      | gopt Opt_PICExecutable dflags       = ["-pie"]+        -- See Note [No PIE when linking]+      | toolSettings_ccSupportsNoPie (toolSettings dflags) = ["-no-pie"]+      | otherwise                           = []+++{-+Note [No PIE while linking]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+As of 2016 some Linux distributions (e.g. Debian) have started enabling -pie by+default in their gcc builds. This is incompatible with -r as it implies that we+are producing an executable. Consequently, we must manually pass -no-pie to gcc+when joining object files or linking dynamic libraries. Unless, of course, the+user has explicitly requested a PIE executable with -pie. See #12759.+-}++picPOpts :: DynFlags -> [String]+picPOpts dflags+ | gopt Opt_PIC dflags = ["-U__PIC__", "-D__PIC__"]+ | otherwise           = []++-- -----------------------------------------------------------------------------+-- Compiler Info++compilerInfo :: DynFlags -> [(String, String)]+compilerInfo dflags+    = -- We always make "Project name" be first to keep parsing in+      -- other languages simple, i.e. when looking for other fields,+      -- you don't have to worry whether there is a leading '[' or not+      ("Project name",                 cProjectName)+      -- Next come the settings, so anything else can be overridden+      -- in the settings file (as "lookup" uses the first match for the+      -- key)+    : map (fmap $ expandDirectories (topDir dflags) (toolDir dflags))+          (rawSettings dflags)+   ++ [("Project version",             projectVersion dflags),+       ("Project Git commit id",       cProjectGitCommitId),+       ("Booter version",              cBooterVersion),+       ("Stage",                       cStage),+       ("Build platform",              cBuildPlatformString),+       ("Host platform",               cHostPlatformString),+       ("Target platform",             platformMisc_targetPlatformString $ platformMisc dflags),+       ("Have interpreter",            showBool $ platformMisc_ghcWithInterpreter $ platformMisc dflags),+       ("Object splitting supported",  showBool False),+       ("Have native code generator",  showBool $ platformMisc_ghcWithNativeCodeGen $ platformMisc dflags),+       -- Whether or not we support @-dynamic-too@+       ("Support dynamic-too",         showBool $ not isWindows),+       -- Whether or not we support the @-j@ flag with @--make@.+       ("Support parallel --make",     "YES"),+       -- Whether or not we support "Foo from foo-0.1-XXX:Foo" syntax in+       -- installed package info.+       ("Support reexported-modules",  "YES"),+       -- Whether or not we support extended @-package foo (Foo)@ syntax.+       ("Support thinning and renaming package flags", "YES"),+       -- Whether or not we support Backpack.+       ("Support Backpack", "YES"),+       -- If true, we require that the 'id' field in installed package info+       -- match what is passed to the @-this-unit-id@ flag for modules+       -- built in it+       ("Requires unified installed package IDs", "YES"),+       -- Whether or not we support the @-this-package-key@ flag.  Prefer+       -- "Uses unit IDs" over it.+       ("Uses package keys",           "YES"),+       -- Whether or not we support the @-this-unit-id@ flag+       ("Uses unit IDs",               "YES"),+       -- Whether or not GHC compiles libraries as dynamic by default+       ("Dynamic by default",          showBool $ dYNAMIC_BY_DEFAULT dflags),+       -- Whether or not GHC was compiled using -dynamic+       ("GHC Dynamic",                 showBool dynamicGhc),+       -- Whether or not GHC was compiled using -prof+       ("GHC Profiled",                showBool rtsIsProfiled),+       ("Debug on",                    showBool debugIsOn),+       ("LibDir",                      topDir dflags),+       -- The path of the global package database used by GHC+       ("Global Package DB",           globalPackageDatabasePath dflags)+      ]+  where+    showBool True  = "YES"+    showBool False = "NO"+    isWindows = platformOS (targetPlatform dflags) == OSMinGW32+    expandDirectories :: FilePath -> Maybe FilePath -> String -> String+    expandDirectories topd mtoold = expandToolDir mtoold . expandTopDir topd++-- Produced by deriveConstants+#include "GHCConstantsHaskellWrappers.hs"++bLOCK_SIZE_W :: DynFlags -> Int+bLOCK_SIZE_W dflags = bLOCK_SIZE dflags `quot` wORD_SIZE dflags++wORD_SIZE_IN_BITS :: DynFlags -> Int+wORD_SIZE_IN_BITS dflags = wORD_SIZE dflags * 8++wordAlignment :: DynFlags -> Alignment+wordAlignment dflags = alignmentOf (wORD_SIZE dflags)++tAG_MASK :: DynFlags -> Int+tAG_MASK dflags = (1 `shiftL` tAG_BITS dflags) - 1++mAX_PTR_TAG :: DynFlags -> Int+mAX_PTR_TAG = tAG_MASK++-- Might be worth caching these in targetPlatform?+tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD :: DynFlags -> Integer+tARGET_MIN_INT dflags+    = case platformWordSize (targetPlatform dflags) of+      PW4 -> toInteger (minBound :: Int32)+      PW8 -> toInteger (minBound :: Int64)+tARGET_MAX_INT dflags+    = case platformWordSize (targetPlatform dflags) of+      PW4 -> toInteger (maxBound :: Int32)+      PW8 -> toInteger (maxBound :: Int64)+tARGET_MAX_WORD dflags+    = case platformWordSize (targetPlatform dflags) of+      PW4 -> toInteger (maxBound :: Word32)+      PW8 -> toInteger (maxBound :: Word64)+++{- -----------------------------------------------------------------------------+Note [DynFlags consistency]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~++There are a number of number of DynFlags configurations which either+do not make sense or lead to unimplemented or buggy codepaths in the+compiler. makeDynFlagsConsistent is responsible for verifying the validity+of a set of DynFlags, fixing any issues, and reporting them back to the+caller.++GHCi and -O+---------------++When using optimization, the compiler can introduce several things+(such as unboxed tuples) into the intermediate code, which GHCi later+chokes on since the bytecode interpreter can't handle this (and while+this is arguably a bug these aren't handled, there are no plans to fix+it.)++While the driver pipeline always checks for this particular erroneous+combination when parsing flags, we also need to check when we update+the flags; this is because API clients may parse flags but update the+DynFlags afterwords, before finally running code inside a session (see+T10052 and #10052).+-}++-- | Resolve any internal inconsistencies in a set of 'DynFlags'.+-- Returns the consistent 'DynFlags' as well as a list of warnings+-- to report to the user.+makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])+-- Whenever makeDynFlagsConsistent does anything, it starts over, to+-- ensure that a later change doesn't invalidate an earlier check.+-- Be careful not to introduce potential loops!+makeDynFlagsConsistent dflags+ -- Disable -dynamic-too on Windows (#8228, #7134, #5987)+ | os == OSMinGW32 && gopt Opt_BuildDynamicToo dflags+    = let dflags' = gopt_unset dflags Opt_BuildDynamicToo+          warn    = "-dynamic-too is not supported on Windows"+      in loop dflags' warn+ | hscTarget dflags == HscC &&+   not (platformUnregisterised (targetPlatform dflags))+    = if platformMisc_ghcWithNativeCodeGen $ platformMisc dflags+      then let dflags' = dflags { hscTarget = HscAsm }+               warn = "Compiler not unregisterised, so using native code generator rather than compiling via C"+           in loop dflags' warn+      else let dflags' = dflags { hscTarget = HscLlvm }+               warn = "Compiler not unregisterised, so using LLVM rather than compiling via C"+           in loop dflags' warn+ | gopt Opt_Hpc dflags && hscTarget dflags == HscInterpreted+    = let dflags' = gopt_unset dflags Opt_Hpc+          warn = "Hpc can't be used with byte-code interpreter. Ignoring -fhpc."+      in loop dflags' warn+ | hscTarget dflags `elem` [HscAsm, HscLlvm] &&+   platformUnregisterised (targetPlatform dflags)+    = loop (dflags { hscTarget = HscC })+           "Compiler unregisterised, so compiling via C"+ | hscTarget dflags == HscAsm &&+   not (platformMisc_ghcWithNativeCodeGen $ platformMisc dflags)+      = let dflags' = dflags { hscTarget = HscLlvm }+            warn = "No native code generator, so using LLVM"+        in loop dflags' warn+ | not (osElfTarget os) && gopt Opt_PIE dflags+    = loop (gopt_unset dflags Opt_PIE)+           "Position-independent only supported on ELF platforms"+ | os == OSDarwin &&+   arch == ArchX86_64 &&+   not (gopt Opt_PIC dflags)+    = loop (gopt_set dflags Opt_PIC)+           "Enabling -fPIC as it is always on for this platform"+ | Left err <- checkOptLevel (optLevel dflags) dflags+    = loop (updOptLevel 0 dflags) err++ | LinkInMemory <- ghcLink dflags+ , not (gopt Opt_ExternalInterpreter dflags)+ , rtsIsProfiled+ , isObjectTarget (hscTarget dflags)+ , WayProf `notElem` ways dflags+    = loop dflags{ways = WayProf : ways dflags}+         "Enabling -prof, because -fobject-code is enabled and GHCi is profiled"++ | otherwise = (dflags, [])+    where loc = mkGeneralSrcSpan (fsLit "when making flags consistent")+          loop updated_dflags warning+              = case makeDynFlagsConsistent updated_dflags of+                (dflags', ws) -> (dflags', L loc warning : ws)+          platform = targetPlatform dflags+          arch = platformArch platform+          os   = platformOS   platform+++--------------------------------------------------------------------------+-- Do not use unsafeGlobalDynFlags!+--+-- unsafeGlobalDynFlags is a hack, necessary because we need to be able+-- to show SDocs when tracing, but we don't always have DynFlags+-- available.+--+-- Do not use it if you can help it. You may get the wrong value, or this+-- panic!++-- | This is the value that 'unsafeGlobalDynFlags' takes before it is+-- initialized.+defaultGlobalDynFlags :: DynFlags+defaultGlobalDynFlags =+    (defaultDynFlags settings llvmConfig) { verbosity = 2 }+  where+    settings = panic "v_unsafeGlobalDynFlags: settings not initialised"+    llvmConfig = panic "v_unsafeGlobalDynFlags: llvmConfig not initialised"++#if GHC_STAGE < 2+GLOBAL_VAR(v_unsafeGlobalDynFlags, defaultGlobalDynFlags, DynFlags)+#else+SHARED_GLOBAL_VAR( v_unsafeGlobalDynFlags+                 , getOrSetLibHSghcGlobalDynFlags+                 , "getOrSetLibHSghcGlobalDynFlags"+                 , defaultGlobalDynFlags+                 , DynFlags )+#endif++unsafeGlobalDynFlags :: DynFlags+unsafeGlobalDynFlags = unsafePerformIO $ readIORef v_unsafeGlobalDynFlags++setUnsafeGlobalDynFlags :: DynFlags -> IO ()+setUnsafeGlobalDynFlags = writeIORef v_unsafeGlobalDynFlags++-- -----------------------------------------------------------------------------+-- SSE and AVX++-- TODO: Instead of using a separate predicate (i.e. isSse2Enabled) to+-- check if SSE is enabled, we might have x86-64 imply the -msse2+-- flag.++data SseVersion = SSE1+                | SSE2+                | SSE3+                | SSE4+                | SSE42+                deriving (Eq, Ord)++isSseEnabled :: DynFlags -> Bool+isSseEnabled dflags = case platformArch (targetPlatform dflags) of+    ArchX86_64 -> True+    ArchX86    -> True+    _          -> False++isSse2Enabled :: DynFlags -> Bool+isSse2Enabled dflags = case platformArch (targetPlatform dflags) of+  -- We Assume  SSE1 and SSE2 operations are available on both+  -- x86 and x86_64. Historically we didn't default to SSE2 and+  -- SSE1 on x86, which results in defacto nondeterminism for how+  -- rounding behaves in the associated x87 floating point instructions+  -- because variations in the spill/fpu stack placement of arguments for+  -- operations would change the precision and final result of what+  -- would otherwise be the same expressions with respect to single or+  -- double precision IEEE floating point computations.+    ArchX86_64 -> True+    ArchX86    -> True+    _          -> False+++isSse4_2Enabled :: DynFlags -> Bool+isSse4_2Enabled dflags = sseVersion dflags >= Just SSE42++isAvxEnabled :: DynFlags -> Bool+isAvxEnabled dflags = avx dflags || avx2 dflags || avx512f dflags++isAvx2Enabled :: DynFlags -> Bool+isAvx2Enabled dflags = avx2 dflags || avx512f dflags++isAvx512cdEnabled :: DynFlags -> Bool+isAvx512cdEnabled dflags = avx512cd dflags++isAvx512erEnabled :: DynFlags -> Bool+isAvx512erEnabled dflags = avx512er dflags++isAvx512fEnabled :: DynFlags -> Bool+isAvx512fEnabled dflags = avx512f dflags++isAvx512pfEnabled :: DynFlags -> Bool+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]+  | UnknownLD+  deriving Eq++-- CompilerInfo tells us which C compiler we're using+data CompilerInfo+   = GCC+   | Clang+   | AppleClang+   | AppleClang51+   | UnknownCC+   deriving Eq++-- -----------------------------------------------------------------------------+-- RTS hooks++-- Convert sizes like "3.5M" into integers+decodeSize :: String -> Integer+decodeSize str+  | c == ""      = truncate n+  | c == "K" || c == "k" = truncate (n * 1000)+  | c == "M" || c == "m" = truncate (n * 1000 * 1000)+  | c == "G" || c == "g" = truncate (n * 1000 * 1000 * 1000)+  | otherwise            = throwGhcException (CmdLineError ("can't decode size: " ++ str))+  where (m, c) = span pred str+        n      = readRational m+        pred c = isDigit c || c == '.'++foreign import ccall unsafe "ghc_lib_parser_setHeapSize"       setHeapSize       :: Int -> IO ()+foreign import ccall unsafe "ghc_lib_parser_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++++initSDocContext :: DynFlags -> PprStyle -> SDocContext+initSDocContext dflags style = SDC+  { sdocStyle                       = style+  , sdocColScheme                   = colScheme dflags+  , sdocLastColour                  = Col.colReset+  , sdocShouldUseColor              = overrideWith (canUseColor dflags) (useColor dflags)+  , sdocLineLength                  = pprCols dflags+  , sdocCanUseUnicode               = useUnicode dflags+  , sdocHexWordLiterals             = gopt Opt_HexWordLiterals dflags+  , sdocDebugLevel                  = debugLevel dflags+  , sdocPprDebug                    = dopt Opt_D_ppr_debug dflags+  , sdocPrintUnicodeSyntax          = gopt Opt_PrintUnicodeSyntax dflags+  , sdocPrintCaseAsLet              = gopt Opt_PprCaseAsLet dflags+  , sdocPrintTypecheckerElaboration = gopt Opt_PrintTypecheckerElaboration dflags+  , sdocPrintAxiomIncomps           = gopt Opt_PrintAxiomIncomps dflags+  , sdocPrintExplicitKinds          = gopt Opt_PrintExplicitKinds dflags+  , sdocPrintExplicitCoercions      = gopt Opt_PrintExplicitCoercions dflags+  , sdocPrintExplicitRuntimeReps    = gopt Opt_PrintExplicitRuntimeReps dflags+  , sdocPrintExplicitForalls        = gopt Opt_PrintExplicitForalls dflags+  , sdocPrintPotentialInstances     = gopt Opt_PrintPotentialInstances dflags+  , sdocPrintEqualityRelations      = gopt Opt_PrintEqualityRelations dflags+  , sdocSuppressTicks               = gopt Opt_SuppressTicks dflags+  , sdocSuppressTypeSignatures      = gopt Opt_SuppressTypeSignatures dflags+  , sdocSuppressTypeApplications    = gopt Opt_SuppressTypeApplications dflags+  , sdocSuppressIdInfo              = gopt Opt_SuppressIdInfo dflags+  , sdocSuppressCoercions           = gopt Opt_SuppressCoercions dflags+  , sdocSuppressUnfoldings          = gopt Opt_SuppressUnfoldings dflags+  , sdocSuppressVarKinds            = gopt Opt_SuppressVarKinds dflags+  , sdocSuppressUniques             = gopt Opt_SuppressUniques dflags+  , sdocSuppressModulePrefixes      = gopt Opt_SuppressModulePrefixes dflags+  , sdocSuppressStgExts             = gopt Opt_SuppressStgExts dflags+  , sdocErrorSpans                  = gopt Opt_ErrorSpans dflags+  , sdocStarIsType                  = xopt LangExt.StarIsType dflags+  , sdocImpredicativeTypes          = xopt LangExt.ImpredicativeTypes dflags+  , sdocDynFlags                    = dflags+  }

+ compiler/GHC/Driver/Session.hs-boot view

@@ -0,0 +1,17 @@+module GHC.Driver.Session where++import GhcPrelude+import GHC.Platform+import {-# SOURCE #-} Outputable++data DynFlags+data DumpFlag+data GeneralFlag++targetPlatform           :: DynFlags -> Platform+pprUserLength            :: DynFlags -> Int+pprCols                  :: DynFlags -> Int+unsafeGlobalDynFlags     :: DynFlags+hasPprDebug              :: DynFlags -> Bool+hasNoDebugOutput         :: DynFlags -> Bool+initSDocContext          :: DynFlags -> PprStyle -> SDocContext

+ compiler/GHC/Driver/Types.hs view

@@ -0,0 +1,3284 @@+{-+(c) The University of Glasgow, 2006++\section[GHC.Driver.Types]{Types for the per-module compiler}+-}++{-# LANGUAGE CPP, ScopedTypeVariables #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE DataKinds #-}++-- | Types for the per-module compiler+module GHC.Driver.Types (+        -- * compilation state+        HscEnv(..), hscEPS,+        FinderCache, FindResult(..), InstalledFindResult(..),+        Target(..), TargetId(..), InputFileBuffer, pprTarget, pprTargetId,+        HscStatus(..),++        -- * ModuleGraph+        ModuleGraph, emptyMG, mkModuleGraph, extendMG, mapMG,+        mgModSummaries, mgElemModule, mgLookupModule,+        needsTemplateHaskellOrQQ, mgBootModules,++        -- * Hsc monad+        Hsc(..), runHsc, mkInteractiveHscEnv, runInteractiveHsc,++        -- * Information about modules+        ModDetails(..), emptyModDetails,+        ModGuts(..), CgGuts(..), ForeignStubs(..), appendStubC,+        ImportedMods, ImportedBy(..), importedByUser, ImportedModsVal(..), SptEntry(..),+        ForeignSrcLang(..),+        phaseForeignLanguage,++        ModSummary(..), ms_imps, ms_installed_mod, ms_mod_name, ms_home_imps,+        home_imps, ms_home_allimps, ms_home_srcimps, showModMsg, isBootSummary,+        msHsFilePath, msHiFilePath, msObjFilePath,+        SourceModified(..), isTemplateHaskellOrQQNonBoot,++        -- * Information about the module being compiled+        -- (re-exported from GHC.Driver.Phases)+        HscSource(..), isHsBootOrSig, isHsigFile, hscSourceString,+++        -- * State relating to modules in this package+        HomePackageTable, HomeModInfo(..), emptyHomePackageTable,+        lookupHpt, eltsHpt, filterHpt, allHpt, mapHpt, delFromHpt,+        addToHpt, addListToHpt, lookupHptDirectly, listToHpt,+        hptCompleteSigs,+        hptInstances, hptRules, pprHPT,++        -- * State relating to known packages+        ExternalPackageState(..), EpsStats(..), addEpsInStats,+        PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,+        lookupIfaceByModule, emptyPartialModIface, emptyFullModIface, lookupHptByModule,++        PackageInstEnv, PackageFamInstEnv, PackageRuleBase,+        PackageCompleteMatchMap,++        mkSOName, mkHsSOName, soExt,++        -- * Metaprogramming+        MetaRequest(..),+        MetaResult, -- data constructors not exported to ensure correct response type+        metaRequestE, metaRequestP, metaRequestT, metaRequestD, metaRequestAW,+        MetaHook,++        -- * Annotations+        prepareAnnotations,++        -- * Interactive context+        InteractiveContext(..), emptyInteractiveContext,+        icPrintUnqual, icInScopeTTs, icExtendGblRdrEnv,+        extendInteractiveContext, extendInteractiveContextWithIds,+        substInteractiveContext,+        setInteractivePrintName, icInteractiveModule,+        InteractiveImport(..), setInteractivePackage,+        mkPrintUnqualified, pprModulePrefix,+        mkQualPackage, mkQualModule, pkgQual,++        -- * Interfaces+        ModIface, PartialModIface, ModIface_(..), ModIfaceBackend(..),+        mkIfaceWarnCache, mkIfaceHashCache, mkIfaceFixCache,+        emptyIfaceWarnCache, mi_boot, mi_fix,+        mi_semantic_module,+        mi_free_holes,+        renameFreeHoles,++        -- * Fixity+        FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,++        -- * TyThings and type environments+        TyThing(..),  tyThingAvailInfo,+        tyThingTyCon, tyThingDataCon, tyThingConLike,+        tyThingId, tyThingCoAxiom, tyThingParent_maybe, tyThingsTyCoVars,+        implicitTyThings, implicitTyConThings, implicitClassThings,+        isImplicitTyThing,++        TypeEnv, lookupType, lookupTypeHscEnv, mkTypeEnv, emptyTypeEnv,+        typeEnvFromEntities, mkTypeEnvWithImplicits,+        extendTypeEnv, extendTypeEnvList,+        extendTypeEnvWithIds, plusTypeEnv,+        lookupTypeEnv,+        typeEnvElts, typeEnvTyCons, typeEnvIds, typeEnvPatSyns,+        typeEnvDataCons, typeEnvCoAxioms, typeEnvClasses,++        -- * MonadThings+        MonadThings(..),++        -- * Information on imports and exports+        WhetherHasOrphans, IsBootInterface, Usage(..),+        Dependencies(..), noDependencies,+        updNameCache,+        IfaceExport,++        -- * Warnings+        Warnings(..), WarningTxt(..), plusWarns,++        -- * Linker stuff+        Linkable(..), isObjectLinkable, linkableObjs,+        Unlinked(..), CompiledByteCode,+        isObject, nameOfObject, isInterpretable, byteCodeOfObject,++        -- * Program coverage+        HpcInfo(..), emptyHpcInfo, isHpcUsed, AnyHpcUsage,++        -- * Breakpoints+        ModBreaks (..), emptyModBreaks,++        -- * Safe Haskell information+        IfaceTrustInfo, getSafeMode, setSafeMode, noIfaceTrustInfo,+        trustInfoToNum, numToTrustInfo, IsSafeImport,++        -- * result of the parser+        HsParsedModule(..),++        -- * Compilation errors and warnings+        SourceError, GhcApiError, mkSrcErr, srcErrorMessages, mkApiErr,+        throwOneError, throwErrors, handleSourceError,+        handleFlagWarnings, printOrThrowWarnings,++        -- * COMPLETE signature+        CompleteMatch(..), CompleteMatchMap,+        mkCompleteMatchMap, extendCompleteMatchMap+    ) where++#include "HsVersions.h"++import GhcPrelude++import GHC.ByteCode.Types+import GHC.Runtime.Eval.Types ( Resume )+import GHC.Runtime.Interpreter.Types (Interp)+import GHC.ForeignSrcLang++import UniqFM+import GHC.Hs+import RdrName+import Avail+import Module+import InstEnv          ( InstEnv, ClsInst, identicalClsInstHead )+import FamInstEnv+import GHC.Core         ( CoreProgram, RuleBase, CoreRule )+import Name+import NameEnv+import VarSet+import Var+import Id+import IdInfo           ( IdDetails(..), RecSelParent(..))+import Type++import ApiAnnotation    ( ApiAnns )+import Annotations      ( Annotation, AnnEnv, mkAnnEnv, plusAnnEnv )+import Class+import TyCon+import CoAxiom+import ConLike+import DataCon+import PatSyn+import PrelNames        ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule )+import TysWiredIn+import GHC.Driver.Packages hiding  ( Version(..) )+import GHC.Driver.CmdLine+import GHC.Driver.Session+import GHC.Runtime.Linker.Types      ( DynLinker, Linkable(..), Unlinked(..), SptEntry(..) )+import GHC.Driver.Phases     ( Phase, HscSource(..), hscSourceString+                        , isHsBootOrSig, isHsigFile )+import qualified GHC.Driver.Phases as Phase+import BasicTypes+import GHC.Iface.Syntax+import Maybes+import Outputable+import SrcLoc+import Unique+import UniqDFM+import FastString+import StringBuffer     ( StringBuffer )+import Fingerprint+import MonadUtils+import Bag+import Binary+import ErrUtils+import NameCache+import GHC.Platform+import Util+import UniqDSet+import GHC.Serialized   ( Serialized )+import qualified GHC.LanguageExtensions as LangExt++import Foreign+import Control.Monad    ( guard, liftM, ap )+import Data.IORef+import Data.Time+import Exception+import System.FilePath+import Control.DeepSeq+import Control.Monad.Trans.Reader+import Control.Monad.Trans.Class++-- -----------------------------------------------------------------------------+-- Compilation state+-- -----------------------------------------------------------------------------++-- | Status of a compilation to hard-code+data HscStatus+    -- | Nothing to do.+    = HscNotGeneratingCode ModIface ModDetails+    -- | Nothing to do because code already exists.+    | HscUpToDate ModIface ModDetails+    -- | Update boot file result.+    | HscUpdateBoot ModIface ModDetails+    -- | Generate signature file (backpack)+    | HscUpdateSig ModIface ModDetails+    -- | Recompile this module.+    | HscRecomp+        { hscs_guts       :: CgGuts+          -- ^ Information for the code generator.+        , hscs_mod_location :: !ModLocation+          -- ^ Module info+        , hscs_mod_details :: !ModDetails+        , hscs_partial_iface  :: !PartialModIface+          -- ^ Partial interface+        , hscs_old_iface_hash :: !(Maybe Fingerprint)+          -- ^ Old interface hash for this compilation, if an old interface file+          -- exists. Pass to `hscMaybeWriteIface` when writing the interface to+          -- avoid updating the existing interface when the interface isn't+          -- changed.+        , hscs_iface_dflags :: !DynFlags+          -- ^ Generate final iface using this DynFlags.+          -- FIXME (osa): I don't understand why this is necessary, but I spent+          -- almost two days trying to figure this out and I couldn't .. perhaps+          -- someone who understands this code better will remove this later.+        }+-- Should HscStatus contain the HomeModInfo?+-- All places where we return a status we also return a HomeModInfo.++-- -----------------------------------------------------------------------------+-- The Hsc monad: Passing an environment and warning state++newtype Hsc a = Hsc (HscEnv -> WarningMessages -> IO (a, WarningMessages))+    deriving (Functor)++instance Applicative Hsc where+    pure a = Hsc $ \_ w -> return (a, w)+    (<*>) = ap++instance Monad Hsc where+    Hsc m >>= k = Hsc $ \e w -> do (a, w1) <- m e w+                                   case k a of+                                       Hsc k' -> k' e w1++instance MonadIO Hsc where+    liftIO io = Hsc $ \_ w -> do a <- io; return (a, w)++instance HasDynFlags Hsc where+    getDynFlags = Hsc $ \e w -> return (hsc_dflags e, w)++runHsc :: HscEnv -> Hsc a -> IO a+runHsc hsc_env (Hsc hsc) = do+    (a, w) <- hsc hsc_env emptyBag+    printOrThrowWarnings (hsc_dflags hsc_env) w+    return a++mkInteractiveHscEnv :: HscEnv -> HscEnv+mkInteractiveHscEnv hsc_env = hsc_env{ hsc_dflags = interactive_dflags }+  where+    interactive_dflags = ic_dflags (hsc_IC hsc_env)++runInteractiveHsc :: HscEnv -> Hsc a -> IO a+-- A variant of runHsc that switches in the DynFlags from the+-- InteractiveContext before running the Hsc computation.+runInteractiveHsc hsc_env = runHsc (mkInteractiveHscEnv hsc_env)++-- -----------------------------------------------------------------------------+-- Source Errors++-- When the compiler (GHC.Driver.Main) discovers errors, it throws an+-- exception in the IO monad.++mkSrcErr :: ErrorMessages -> SourceError+mkSrcErr = SourceError++srcErrorMessages :: SourceError -> ErrorMessages+srcErrorMessages (SourceError msgs) = msgs++mkApiErr :: DynFlags -> SDoc -> GhcApiError+mkApiErr dflags msg = GhcApiError (showSDoc dflags msg)++throwErrors :: MonadIO io => ErrorMessages -> io a+throwErrors = liftIO . throwIO . mkSrcErr++throwOneError :: MonadIO io => ErrMsg -> io a+throwOneError = throwErrors . unitBag++-- | A source error is an error that is caused by one or more errors in the+-- source code.  A 'SourceError' is thrown by many functions in the+-- compilation pipeline.  Inside GHC these errors are merely printed via+-- 'log_action', but API clients may treat them differently, for example,+-- insert them into a list box.  If you want the default behaviour, use the+-- idiom:+--+-- > handleSourceError printExceptionAndWarnings $ do+-- >   ... api calls that may fail ...+--+-- The 'SourceError's error messages can be accessed via 'srcErrorMessages'.+-- This list may be empty if the compiler failed due to @-Werror@+-- ('Opt_WarnIsError').+--+-- See 'printExceptionAndWarnings' for more information on what to take care+-- of when writing a custom error handler.+newtype SourceError = SourceError ErrorMessages++instance Show SourceError where+  show (SourceError msgs) = unlines . map show . bagToList $ msgs++instance Exception SourceError++-- | Perform the given action and call the exception handler if the action+-- throws a 'SourceError'.  See 'SourceError' for more information.+handleSourceError :: (ExceptionMonad m) =>+                     (SourceError -> m a) -- ^ exception handler+                  -> m a -- ^ action to perform+                  -> m a+handleSourceError handler act =+  gcatch act (\(e :: SourceError) -> handler e)++-- | An error thrown if the GHC API is used in an incorrect fashion.+newtype GhcApiError = GhcApiError String++instance Show GhcApiError where+  show (GhcApiError msg) = msg++instance Exception GhcApiError++-- | 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 = 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 -> [Warn] -> IO ()+handleFlagWarnings dflags warns = do+  let warns' = filter (shouldPrintWarning dflags . warnReason)  warns++      -- 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 -> GHC.Driver.CmdLine.WarnReason -> Bool+shouldPrintWarning dflags ReasonDeprecatedFlag+  = wopt Opt_WarnDeprecatedFlags dflags+shouldPrintWarning dflags ReasonUnrecognisedFlag+  = wopt Opt_WarnUnrecognisedWarningFlags dflags+shouldPrintWarning _ _+  = True++{-+************************************************************************+*                                                                      *+\subsection{HscEnv}+*                                                                      *+************************************************************************+-}++-- | HscEnv is like 'Session', except that some of the fields are immutable.+-- An HscEnv is used to compile a single module from plain Haskell source+-- code (after preprocessing) to either C, assembly or C--. It's also used+-- to store the dynamic linker state to allow for multiple linkers in the+-- same address space.+-- Things like the module graph don't change during a single compilation.+--+-- Historical note: \"hsc\" used to be the name of the compiler binary,+-- when there was a separate driver and compiler.  To compile a single+-- module, the driver would invoke hsc on the source code... so nowadays+-- we think of hsc as the layer of the compiler that deals with compiling+-- a single module.+data HscEnv+  = HscEnv {+        hsc_dflags :: DynFlags,+                -- ^ The dynamic flag settings++        hsc_targets :: [Target],+                -- ^ The targets (or roots) of the current session++        hsc_mod_graph :: ModuleGraph,+                -- ^ The module graph of the current session++        hsc_IC :: InteractiveContext,+                -- ^ The context for evaluating interactive statements++        hsc_HPT    :: HomePackageTable,+                -- ^ The home package table describes already-compiled+                -- home-package modules, /excluding/ the module we+                -- are compiling right now.+                -- (In one-shot mode the current module is the only+                -- home-package module, so hsc_HPT is empty.  All other+                -- modules count as \"external-package\" modules.+                -- However, even in GHCi mode, hi-boot interfaces are+                -- demand-loaded into the external-package table.)+                --+                -- 'hsc_HPT' is not mutable because we only demand-load+                -- external packages; the home package is eagerly+                -- loaded, module by module, by the compilation manager.+                --+                -- The HPT may contain modules compiled earlier by @--make@+                -- but not actually below the current module in the dependency+                -- graph.+                --+                -- (This changes a previous invariant: changed Jan 05.)++        hsc_EPS :: {-# UNPACK #-} !(IORef ExternalPackageState),+                -- ^ Information about the currently loaded external packages.+                -- This is mutable because packages will be demand-loaded during+                -- a compilation run as required.++        hsc_NC  :: {-# UNPACK #-} !(IORef NameCache),+                -- ^ As with 'hsc_EPS', this is side-effected by compiling to+                -- reflect sucking in interface files.  They cache the state of+                -- external interface files, in effect.++        hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),+                -- ^ The cached result of performing finding in the file system++        hsc_type_env_var :: Maybe (Module, IORef TypeEnv)+                -- ^ Used for one-shot compilation only, to initialise+                -- the 'IfGblEnv'. See 'TcRnTypes.tcg_type_env_var' for+                -- 'TcRnTypes.TcGblEnv'.  See also Note [hsc_type_env_var hack]++        , hsc_interp :: Maybe Interp+                -- ^ target code interpreter (if any) to use for TH and GHCi.+                -- See Note [Target code interpreter]++        , hsc_dynLinker :: DynLinker+                -- ^ dynamic linker.++ }++{-++Note [Target code interpreter]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++Template Haskell and GHCi use an interpreter to execute code that is built for+the compiler target platform (= code host platform) on the compiler host+platform (= code build platform).++The internal interpreter can be used when both platforms are the same and when+the built code is compatible with the compiler itself (same way, etc.). This+interpreter is not always available: for instance stage1 compiler doesn't have+it because there might be an ABI mismatch between the code objects (built by+stage1 compiler) and the stage1 compiler itself (built by stage0 compiler).++In most cases, an external interpreter can be used instead: it runs in a+separate process and it communicates with the compiler via a two-way message+passing channel. The process is lazily spawned to avoid overhead when it is not+used.++The target code interpreter to use can be selected per session via the+`hsc_interp` field of `HscEnv`. There may be no interpreter available at all, in+which case Template Haskell and GHCi will fail to run. The interpreter to use is+configured via command-line flags (in `GHC.setSessionDynFlags`).+++-}++-- Note [hsc_type_env_var hack]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- hsc_type_env_var is used to initialize tcg_type_env_var, and+-- eventually it is the mutable variable that is queried from+-- if_rec_types to get a TypeEnv.  So, clearly, it's something+-- related to knot-tying (see Note [Tying the knot]).+-- hsc_type_env_var is used in two places: initTcRn (where+-- it initializes tcg_type_env_var) and initIfaceCheck+-- (where it initializes if_rec_types).+--+-- But why do we need a way to feed a mutable variable in?  Why+-- can't we just initialize tcg_type_env_var when we start+-- typechecking?  The problem is we need to knot-tie the+-- EPS, and we may start adding things to the EPS before type+-- checking starts.+--+-- Here is a concrete example. Suppose we are running+-- "ghc -c A.hs", and we have this file system state:+--+--  A.hs-boot   A.hi-boot **up to date**+--  B.hs        B.hi      **up to date**+--  A.hs        A.hi      **stale**+--+-- The first thing we do is run checkOldIface on A.hi.+-- checkOldIface will call loadInterface on B.hi so it can+-- get its hands on the fingerprints, to find out if A.hi+-- needs recompilation.  But loadInterface also populates+-- the EPS!  And so if compilation turns out to be necessary,+-- as it is in this case, the thunks we put into the EPS for+-- B.hi need to have the correct if_rec_types mutable variable+-- to query.+--+-- If the mutable variable is only allocated WHEN we start+-- typechecking, then that's too late: we can't get the+-- information to the thunks.  So we need to pre-commit+-- to a type variable in 'hscIncrementalCompile' BEFORE we+-- check the old interface.+--+-- This is all a massive hack because arguably checkOldIface+-- should not populate the EPS. But that's a refactor for+-- another day.++-- | Retrieve the ExternalPackageState cache.+hscEPS :: HscEnv -> IO ExternalPackageState+hscEPS hsc_env = readIORef (hsc_EPS hsc_env)++-- | A compilation target.+--+-- A target may be supplied with the actual text of the+-- module.  If so, use this instead of the file contents (this+-- is for use in an IDE where the file hasn't been saved by+-- the user yet).+data Target+  = Target {+      targetId           :: TargetId, -- ^ module or filename+      targetAllowObjCode :: Bool,     -- ^ object code allowed?+      targetContents     :: Maybe (InputFileBuffer, UTCTime)+      -- ^ Optional in-memory buffer containing the source code GHC should+      -- use for this target instead of reading it from disk.+      --+      -- Since GHC version 8.10 modules which require preprocessors such as+      -- Literate Haskell or CPP to run are also supported.+      --+      -- If a corresponding source file does not exist on disk this will+      -- result in a 'SourceError' exception if @targetId = TargetModule _@+      -- is used. However together with @targetId = TargetFile _@ GHC will+      -- not complain about the file missing.+    }++data TargetId+  = TargetModule ModuleName+        -- ^ A module name: search for the file+  | TargetFile FilePath (Maybe Phase)+        -- ^ A filename: preprocess & parse it to find the module name.+        -- If specified, the Phase indicates how to compile this file+        -- (which phase to start from).  Nothing indicates the starting phase+        -- should be determined from the suffix of the filename.+  deriving Eq++type InputFileBuffer = StringBuffer++pprTarget :: Target -> SDoc+pprTarget (Target id obj _) =+    (if obj then char '*' else empty) <> pprTargetId id++instance Outputable Target where+    ppr = pprTarget++pprTargetId :: TargetId -> SDoc+pprTargetId (TargetModule m) = ppr m+pprTargetId (TargetFile f _) = text f++instance Outputable TargetId where+    ppr = pprTargetId++{-+************************************************************************+*                                                                      *+\subsection{Package and Module Tables}+*                                                                      *+************************************************************************+-}++-- | Helps us find information about modules in the home package+type HomePackageTable  = DModuleNameEnv HomeModInfo+        -- Domain = modules in the home package that have been fully compiled+        -- "home" unit id cached here for convenience++-- | Helps us find information about modules in the imported packages+type PackageIfaceTable = ModuleEnv ModIface+        -- Domain = modules in the imported packages++-- | Constructs an empty HomePackageTable+emptyHomePackageTable :: HomePackageTable+emptyHomePackageTable  = emptyUDFM++-- | Constructs an empty PackageIfaceTable+emptyPackageIfaceTable :: PackageIfaceTable+emptyPackageIfaceTable = emptyModuleEnv++pprHPT :: HomePackageTable -> SDoc+-- A bit arbitrary for now+pprHPT hpt = pprUDFM hpt $ \hms ->+    vcat [ hang (ppr (mi_module (hm_iface hm)))+              2 (ppr (md_types (hm_details hm)))+         | hm <- hms ]++lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo+lookupHpt = lookupUDFM++lookupHptDirectly :: HomePackageTable -> Unique -> Maybe HomeModInfo+lookupHptDirectly = lookupUDFM_Directly++eltsHpt :: HomePackageTable -> [HomeModInfo]+eltsHpt = eltsUDFM++filterHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> HomePackageTable+filterHpt = filterUDFM++allHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> Bool+allHpt = allUDFM++mapHpt :: (HomeModInfo -> HomeModInfo) -> HomePackageTable -> HomePackageTable+mapHpt = mapUDFM++delFromHpt :: HomePackageTable -> ModuleName -> HomePackageTable+delFromHpt = delFromUDFM++addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable+addToHpt = addToUDFM++addListToHpt+  :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable+addListToHpt = addListToUDFM++listToHpt :: [(ModuleName, HomeModInfo)] -> HomePackageTable+listToHpt = listToUDFM++lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo+-- The HPT is indexed by ModuleName, not Module,+-- we must check for a hit on the right Module+lookupHptByModule hpt mod+  = case lookupHpt hpt (moduleName mod) of+      Just hm | mi_module (hm_iface hm) == mod -> Just hm+      _otherwise                               -> Nothing++-- | Information about modules in the package being compiled+data HomeModInfo+  = HomeModInfo {+      hm_iface    :: !ModIface,+        -- ^ The basic loaded interface file: every loaded module has one of+        -- these, even if it is imported from another package+      hm_details  :: !ModDetails,+        -- ^ Extra information that has been created from the 'ModIface' for+        -- the module, typically during typechecking+      hm_linkable :: !(Maybe Linkable)+        -- ^ The actual artifact we would like to link to access things in+        -- this module.+        --+        -- 'hm_linkable' might be Nothing:+        --+        --   1. If this is an .hs-boot module+        --+        --   2. Temporarily during compilation if we pruned away+        --      the old linkable because it was out of date.+        --+        -- After a complete compilation ('GHC.load'), all 'hm_linkable' fields+        -- in the 'HomePackageTable' will be @Just@.+        --+        -- When re-linking a module ('GHC.Driver.Main.HscNoRecomp'), we construct the+        -- 'HomeModInfo' by building a new 'ModDetails' from the old+        -- 'ModIface' (only).+    }++-- | Find the 'ModIface' for a 'Module', searching in both the loaded home+-- and external package module information+lookupIfaceByModule+        :: HomePackageTable+        -> PackageIfaceTable+        -> Module+        -> Maybe ModIface+lookupIfaceByModule hpt pit mod+  = case lookupHptByModule hpt mod of+       Just hm -> Just (hm_iface hm)+       Nothing -> lookupModuleEnv pit mod++-- If the module does come from the home package, why do we look in the PIT as well?+-- (a) In OneShot mode, even home-package modules accumulate in the PIT+-- (b) Even in Batch (--make) mode, there is *one* case where a home-package+--     module is in the PIT, namely GHC.Prim when compiling the base package.+-- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package+-- of its own, but it doesn't seem worth the bother.++hptCompleteSigs :: HscEnv -> [CompleteMatch]+hptCompleteSigs = hptAllThings  (md_complete_sigs . hm_details)++-- | Find all the instance declarations (of classes and families) from+-- the Home Package Table filtered by the provided predicate function.+-- Used in @tcRnImports@, to select the instances that are in the+-- transitive closure of imports from the currently compiled module.+hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])+hptInstances hsc_env want_this_module+  = let (insts, famInsts) = unzip $ flip hptAllThings hsc_env $ \mod_info -> do+                guard (want_this_module (moduleName (mi_module (hm_iface mod_info))))+                let details = hm_details mod_info+                return (md_insts details, md_fam_insts details)+    in (concat insts, concat famInsts)++-- | Get rules from modules "below" this one (in the dependency sense)+hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]+hptRules = hptSomeThingsBelowUs (md_rules . hm_details) False+++-- | Get annotations from modules "below" this one (in the dependency sense)+hptAnns :: HscEnv -> Maybe [(ModuleName, IsBootInterface)] -> [Annotation]+hptAnns hsc_env (Just deps) = hptSomeThingsBelowUs (md_anns . hm_details) False hsc_env deps+hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env++hptAllThings :: (HomeModInfo -> [a]) -> HscEnv -> [a]+hptAllThings extract hsc_env = concatMap extract (eltsHpt (hsc_HPT hsc_env))++-- | Get things from modules "below" this one (in the dependency sense)+-- C.f Inst.hptInstances+hptSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> [(ModuleName, IsBootInterface)] -> [a]+hptSomeThingsBelowUs extract include_hi_boot hsc_env deps+  | isOneShot (ghcMode (hsc_dflags hsc_env)) = []++  | otherwise+  = let hpt = hsc_HPT hsc_env+    in+    [ thing+    |   -- Find each non-hi-boot module below me+      (mod, is_boot_mod) <- deps+    , include_hi_boot || not is_boot_mod++        -- unsavoury: when compiling the base package with --make, we+        -- sometimes try to look up RULES etc for GHC.Prim. GHC.Prim won't+        -- be in the HPT, because we never compile it; it's in the EPT+        -- instead. ToDo: clean up, and remove this slightly bogus filter:+    , mod /= moduleName gHC_PRIM++        -- Look it up in the HPT+    , let things = case lookupHpt hpt mod of+                    Just info -> extract info+                    Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg []+          msg = vcat [text "missing module" <+> ppr mod,+                      text "Probable cause: out-of-date interface files"]+                        -- This really shouldn't happen, but see #962++        -- And get its dfuns+    , thing <- things ]+++{-+************************************************************************+*                                                                      *+\subsection{Metaprogramming}+*                                                                      *+************************************************************************+-}++-- | The supported metaprogramming result types+data MetaRequest+  = 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 GhcPs   }+  | MetaResP  { unMetaResP  :: LPat GhcPs      }+  | MetaResT  { unMetaResT  :: LHsType GhcPs   }+  | MetaResD  { unMetaResD  :: [LHsDecl GhcPs] }+  | MetaResAW { unMetaResAW :: Serialized        }++type MetaHook f = MetaRequest -> LHsExpr GhcTc -> f MetaResult++metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)+metaRequestE h = fmap unMetaResE . h (MetaE MetaResE)++metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)+metaRequestP h = fmap unMetaResP . h (MetaP MetaResP)++metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)+metaRequestT h = fmap unMetaResT . h (MetaT MetaResT)++metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]+metaRequestD h = fmap unMetaResD . h (MetaD MetaResD)++metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized+metaRequestAW h = fmap unMetaResAW . h (MetaAW MetaResAW)++{-+************************************************************************+*                                                                      *+\subsection{Dealing with Annotations}+*                                                                      *+************************************************************************+-}++-- | Deal with gathering annotations in from all possible places+--   and combining them into a single 'AnnEnv'+prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv+prepareAnnotations hsc_env mb_guts = do+    eps <- hscEPS hsc_env+    let -- Extract annotations from the module being compiled if supplied one+        mb_this_module_anns = fmap (mkAnnEnv . mg_anns) mb_guts+        -- Extract dependencies of the module if we are supplied one,+        -- otherwise load annotations from all home package table+        -- entries regardless of dependency ordering.+        home_pkg_anns  = (mkAnnEnv . hptAnns hsc_env) $ fmap (dep_mods . mg_deps) mb_guts+        other_pkg_anns = eps_ann_env eps+        ann_env        = foldl1' plusAnnEnv $ catMaybes [mb_this_module_anns,+                                                         Just home_pkg_anns,+                                                         Just other_pkg_anns]+    return ann_env++{-+************************************************************************+*                                                                      *+\subsection{The Finder cache}+*                                                                      *+************************************************************************+-}++-- | The 'FinderCache' maps modules to the result of+-- searching for that module. It records the results of searching for+-- modules along the search path. On @:load@, we flush the entire+-- contents of this cache.+--+type FinderCache = InstalledModuleEnv InstalledFindResult++data InstalledFindResult+  = InstalledFound ModLocation InstalledModule+  | InstalledNoPackage InstalledUnitId+  | InstalledNotFound [FilePath] (Maybe InstalledUnitId)++-- | The result of searching for an imported module.+--+-- NB: FindResult manages both user source-import lookups+-- (which can result in 'Module') as well as direct imports+-- for interfaces (which always result in 'InstalledModule').+data FindResult+  = Found ModLocation Module+        -- ^ The module was found+  | NoPackage UnitId+        -- ^ The requested package was not found+  | FoundMultiple [(Module, ModuleOrigin)]+        -- ^ _Error_: both in multiple packages++        -- | Not found+  | NotFound+      { fr_paths       :: [FilePath]       -- Places where I looked++      , fr_pkg         :: Maybe UnitId  -- Just p => module is in this package's+                                           --           manifest, but couldn't find+                                           --           the .hi file++      , fr_mods_hidden :: [UnitId]      -- Module is in these packages,+                                           --   but the *module* is hidden++      , fr_pkgs_hidden :: [UnitId]      -- Module is in these packages,+                                           --   but the *package* is hidden++        -- Modules are in these packages, but it is unusable+      , fr_unusables   :: [(UnitId, UnusablePackageReason)]++      , fr_suggestions :: [ModuleSuggestion] -- Possible mis-spelled modules+      }++{-+************************************************************************+*                                                                      *+\subsection{Symbol tables and Module details}+*                                                                      *+************************************************************************+-}++{- Note [Interface file stages]+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~++Interface files have two possible stages.++* A partial stage built from the result of the core pipeline.+* A fully instantiated form. Which also includes fingerprints and+  potentially information provided by backends.++We can build a full interface file two ways:+* Directly from a partial one:+  Then we omit backend information and mostly compute fingerprints.+* From a partial one + information produced by a backend.+  Then we store the provided information and fingerprint both.+-}++type PartialModIface = ModIface_ 'ModIfaceCore+type ModIface = ModIface_ 'ModIfaceFinal++-- | Extends a PartialModIface with information which is either:+-- * Computed after codegen+-- * Or computed just before writing the iface to disk. (Hashes)+-- In order to fully instantiate it.+data ModIfaceBackend = ModIfaceBackend+  { 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 the module, excluding+    -- optimisation flags+  , mi_opt_hash :: !Fingerprint+    -- ^ Hash of optimisation flags+  , mi_hpc_hash :: !Fingerprint+    -- ^ Hash of hpc flags+  , mi_plugin_hash :: !Fingerprint+    -- ^ Hash of plugins+  , mi_orphan :: !WhetherHasOrphans+    -- ^ Whether this module has orphans+  , mi_finsts :: !WhetherHasFamInst+    -- ^ Whether this module has family instances. See Note [The type family+    -- instance consistency story].+  , mi_exp_hash :: !Fingerprint+    -- ^ Hash of export list+  , mi_orphan_hash :: !Fingerprint+    -- ^ Hash for orphan rules, class and family instances combined++    -- Cached environments for easy lookup. These are computed (lazily) from+    -- other fields and are not put into the interface file.+    -- Not really produced by the backend but there is no need to create them+    -- any earlier.+  , mi_warn_fn :: !(OccName -> Maybe WarningTxt)+    -- ^ Cached lookup for 'mi_warns'+  , mi_fix_fn :: !(OccName -> Maybe Fixity)+    -- ^ Cached lookup for 'mi_fixities'+  , mi_hash_fn :: !(OccName -> Maybe (OccName, Fingerprint))+    -- ^ Cached lookup for 'mi_decls'. The @Nothing@ in 'mi_hash_fn' means that+    -- the thing isn't in decls. It's useful to know that when seeing if we are+    -- up to date wrt. the old interface. The 'OccName' is the parent of the+    -- name, if it has one.+  }++data ModIfacePhase+  = ModIfaceCore+  -- ^ Partial interface built based on output of core pipeline.+  | ModIfaceFinal++-- | Selects a IfaceDecl representation.+-- For fully instantiated interfaces we also maintain+-- a fingerprint, which is used for recompilation checks.+type family IfaceDeclExts (phase :: ModIfacePhase) where+  IfaceDeclExts 'ModIfaceCore = IfaceDecl+  IfaceDeclExts 'ModIfaceFinal = (Fingerprint, IfaceDecl)++type family IfaceBackendExts (phase :: ModIfacePhase) where+  IfaceBackendExts 'ModIfaceCore = ()+  IfaceBackendExts 'ModIfaceFinal = ModIfaceBackend++++-- | A 'ModIface' plus a 'ModDetails' summarises everything we know+-- about a compiled module.  The 'ModIface' is the stuff *before* linking,+-- and can be written out to an interface file. The 'ModDetails is after+-- linking and can be completely recovered from just the 'ModIface'.+--+-- When we read an interface file, we also construct a 'ModIface' from it,+-- except that we explicitly make the 'mi_decls' and a few other fields empty;+-- as when reading we consolidate the declarations etc. into a number of indexed+-- maps and environments in the 'ExternalPackageState'.+data ModIface_ (phase :: ModIfacePhase)+  = ModIface {+        mi_module     :: !Module,             -- ^ Name of the module we are for+        mi_sig_of     :: !(Maybe Module),     -- ^ Are we a sig of another mod?++        mi_hsc_src    :: !HscSource,          -- ^ Boot? Signature?++        mi_deps     :: Dependencies,+                -- ^ The dependencies of the module.  This is+                -- consulted for directly-imported modules, but not+                -- for anything else (hence lazy)++        mi_usages   :: [Usage],+                -- ^ Usages; kept sorted so that it's easy to decide+                -- whether to write a new iface file (changing usages+                -- doesn't affect the hash of this module)+                -- NOT STRICT!  we read this field lazily from the interface file+                -- It is *only* consulted by the recompilation checker++        mi_exports  :: ![IfaceExport],+                -- ^ Exports+                -- Kept sorted by (mod,occ), to make version comparisons easier+                -- Records the modules that are the declaration points for things+                -- exported by this module, and the 'OccName's of those things+++        mi_used_th  :: !Bool,+                -- ^ Module required TH splices when it was compiled.+                -- This disables recompilation avoidance (see #481).++        mi_fixities :: [(OccName,Fixity)],+                -- ^ Fixities+                -- NOT STRICT!  we read this field lazily from the interface file++        mi_warns    :: Warnings,+                -- ^ Warnings+                -- NOT STRICT!  we read this field lazily from the interface file++        mi_anns     :: [IfaceAnnotation],+                -- ^ Annotations+                -- NOT STRICT!  we read this field lazily from the interface file+++        mi_decls    :: [IfaceDeclExts phase],+                -- ^ Type, class and variable declarations+                -- The hash of an Id changes if its fixity or deprecations change+                --      (as well as its type of course)+                -- Ditto data constructors, class operations, except that+                -- the hash of the parent class/tycon changes++        mi_globals  :: !(Maybe GlobalRdrEnv),+                -- ^ Binds all the things defined at the top level in+                -- the /original source/ code for this module. which+                -- is NOT the same as mi_exports, nor mi_decls (which+                -- may contains declarations for things not actually+                -- defined by the user).  Used for GHCi and for inspecting+                -- the contents of modules via the GHC API only.+                --+                -- (We need the source file to figure out the+                -- top-level environment, if we didn't compile this module+                -- from source then this field contains @Nothing@).+                --+                -- Strictly speaking this field should live in the+                -- 'HomeModInfo', but that leads to more plumbing.++                -- Instance declarations and rules+        mi_insts       :: [IfaceClsInst],     -- ^ Sorted class instance+        mi_fam_insts   :: [IfaceFamInst],  -- ^ Sorted family instances+        mi_rules       :: [IfaceRule],     -- ^ Sorted rules++        mi_hpc       :: !AnyHpcUsage,+                -- ^ True if this program uses Hpc at any point in the program.++        mi_trust     :: !IfaceTrustInfo,+                -- ^ Safe Haskell Trust information for this module.++        mi_trust_pkg :: !Bool,+                -- ^ Do we require the package this module resides in be trusted+                -- to trust this module? This is used for the situation where a+                -- module is Safe (so doesn't require the package be trusted+                -- itself) but imports some trustworthy modules from its own+                -- package (which does require its own package be trusted).+                -- See Note [Trust Own Package] in GHC.Rename.Names+        mi_complete_sigs :: [IfaceCompleteMatch],++        mi_doc_hdr :: Maybe HsDocString,+                -- ^ Module header.++        mi_decl_docs :: DeclDocMap,+                -- ^ Docs on declarations.++        mi_arg_docs :: ArgDocMap,+                -- ^ Docs on arguments.++        mi_final_exts :: !(IfaceBackendExts phase)+                -- ^ Either `()` or `ModIfaceBackend` for+                -- a fully instantiated interface.+     }++-- | Old-style accessor for whether or not the ModIface came from an hs-boot+-- file.+mi_boot :: ModIface -> Bool+mi_boot iface = mi_hsc_src iface == HsBootFile++-- | Lookups up a (possibly cached) fixity from a 'ModIface'. If one cannot be+-- found, 'defaultFixity' is returned instead.+mi_fix :: ModIface -> OccName -> Fixity+mi_fix iface name = mi_fix_fn (mi_final_exts iface) name `orElse` defaultFixity++-- | The semantic module for this interface; e.g., if it's a interface+-- for a signature, if 'mi_module' is @p[A=<A>]:A@, 'mi_semantic_module'+-- will be @<A>@.+mi_semantic_module :: ModIface_ a -> Module+mi_semantic_module iface = case mi_sig_of iface of+                            Nothing -> mi_module iface+                            Just mod -> mod++-- | The "precise" free holes, e.g., the signatures that this+-- 'ModIface' depends on.+mi_free_holes :: ModIface -> UniqDSet ModuleName+mi_free_holes iface =+  case splitModuleInsts (mi_module iface) of+    (_, Just indef)+        -- A mini-hack: we rely on the fact that 'renameFreeHoles'+        -- drops things that aren't holes.+        -> renameFreeHoles (mkUniqDSet cands) (indefUnitIdInsts (indefModuleUnitId indef))+    _   -> emptyUniqDSet+  where+    cands = map fst (dep_mods (mi_deps iface))++-- | Given a set of free holes, and a unit identifier, rename+-- the free holes according to the instantiation of the unit+-- identifier.  For example, if we have A and B free, and+-- our unit identity is @p[A=<C>,B=impl:B]@, the renamed free+-- holes are just C.+renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName+renameFreeHoles fhs insts =+    unionManyUniqDSets (map lookup_impl (uniqDSetToList fhs))+  where+    hmap = listToUFM insts+    lookup_impl mod_name+        | Just mod <- lookupUFM hmap mod_name = moduleFreeHoles mod+        -- It wasn't actually a hole+        | otherwise                           = emptyUniqDSet++instance Binary ModIface where+   put_ bh (ModIface {+                 mi_module    = mod,+                 mi_sig_of    = sig_of,+                 mi_hsc_src   = hsc_src,+                 mi_deps      = deps,+                 mi_usages    = usages,+                 mi_exports   = exports,+                 mi_used_th   = used_th,+                 mi_fixities  = fixities,+                 mi_warns     = warns,+                 mi_anns      = anns,+                 mi_decls     = decls,+                 mi_insts     = insts,+                 mi_fam_insts = fam_insts,+                 mi_rules     = rules,+                 mi_hpc       = hpc_info,+                 mi_trust     = trust,+                 mi_trust_pkg = trust_pkg,+                 mi_complete_sigs = complete_sigs,+                 mi_doc_hdr   = doc_hdr,+                 mi_decl_docs = decl_docs,+                 mi_arg_docs  = arg_docs,+                 mi_final_exts = ModIfaceBackend {+                   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_plugin_hash = plugin_hash,+                   mi_orphan = orphan,+                   mi_finsts = hasFamInsts,+                   mi_exp_hash = exp_hash,+                   mi_orphan_hash = orphan_hash+                 }}) = do+        put_ bh mod+        put_ bh sig_of+        put_ bh hsc_src+        put_ bh iface_hash+        put_ bh mod_hash+        put_ bh flag_hash+        put_ bh opt_hash+        put_ bh hpc_hash+        put_ bh plugin_hash+        put_ bh orphan+        put_ bh hasFamInsts+        lazyPut bh deps+        lazyPut bh usages+        put_ bh exports+        put_ bh exp_hash+        put_ bh used_th+        put_ bh fixities+        lazyPut bh warns+        lazyPut bh anns+        put_ bh decls+        put_ bh insts+        put_ bh fam_insts+        lazyPut bh rules+        put_ bh orphan_hash+        put_ bh hpc_info+        put_ bh trust+        put_ bh trust_pkg+        put_ bh complete_sigs+        lazyPut bh doc_hdr+        lazyPut bh decl_docs+        lazyPut bh arg_docs++   get bh = do+        mod         <- get bh+        sig_of      <- get bh+        hsc_src     <- get bh+        iface_hash  <- get bh+        mod_hash    <- get bh+        flag_hash   <- get bh+        opt_hash    <- get bh+        hpc_hash    <- get bh+        plugin_hash <- get bh+        orphan      <- get bh+        hasFamInsts <- get bh+        deps        <- lazyGet bh+        usages      <- {-# SCC "bin_usages" #-} lazyGet bh+        exports     <- {-# SCC "bin_exports" #-} get bh+        exp_hash    <- get bh+        used_th     <- get bh+        fixities    <- {-# SCC "bin_fixities" #-} get bh+        warns       <- {-# SCC "bin_warns" #-} lazyGet bh+        anns        <- {-# SCC "bin_anns" #-} lazyGet bh+        decls       <- {-# SCC "bin_tycldecls" #-} get bh+        insts       <- {-# SCC "bin_insts" #-} get bh+        fam_insts   <- {-# SCC "bin_fam_insts" #-} get bh+        rules       <- {-# SCC "bin_rules" #-} lazyGet bh+        orphan_hash <- get bh+        hpc_info    <- get bh+        trust       <- get bh+        trust_pkg   <- get bh+        complete_sigs <- get bh+        doc_hdr     <- lazyGet bh+        decl_docs   <- lazyGet bh+        arg_docs    <- lazyGet bh+        return (ModIface {+                 mi_module      = mod,+                 mi_sig_of      = sig_of,+                 mi_hsc_src     = hsc_src,+                 mi_deps        = deps,+                 mi_usages      = usages,+                 mi_exports     = exports,+                 mi_used_th     = used_th,+                 mi_anns        = anns,+                 mi_fixities    = fixities,+                 mi_warns       = warns,+                 mi_decls       = decls,+                 mi_globals     = Nothing,+                 mi_insts       = insts,+                 mi_fam_insts   = fam_insts,+                 mi_rules       = rules,+                 mi_hpc         = hpc_info,+                 mi_trust       = trust,+                 mi_trust_pkg   = trust_pkg,+                        -- And build the cached values+                 mi_complete_sigs = complete_sigs,+                 mi_doc_hdr     = doc_hdr,+                 mi_decl_docs   = decl_docs,+                 mi_arg_docs    = arg_docs,+                 mi_final_exts = ModIfaceBackend {+                   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_plugin_hash = plugin_hash,+                   mi_orphan = orphan,+                   mi_finsts = hasFamInsts,+                   mi_exp_hash = exp_hash,+                   mi_orphan_hash = orphan_hash,+                   mi_warn_fn = mkIfaceWarnCache warns,+                   mi_fix_fn = mkIfaceFixCache fixities,+                   mi_hash_fn = mkIfaceHashCache decls+                 }})++-- | The original names declared of a certain module that are exported+type IfaceExport = AvailInfo++emptyPartialModIface :: Module -> PartialModIface+emptyPartialModIface mod+  = ModIface { mi_module      = mod,+               mi_sig_of      = Nothing,+               mi_hsc_src     = HsSrcFile,+               mi_deps        = noDependencies,+               mi_usages      = [],+               mi_exports     = [],+               mi_used_th     = False,+               mi_fixities    = [],+               mi_warns       = NoWarnings,+               mi_anns        = [],+               mi_insts       = [],+               mi_fam_insts   = [],+               mi_rules       = [],+               mi_decls       = [],+               mi_globals     = Nothing,+               mi_hpc         = False,+               mi_trust       = noIfaceTrustInfo,+               mi_trust_pkg   = False,+               mi_complete_sigs = [],+               mi_doc_hdr     = Nothing,+               mi_decl_docs   = emptyDeclDocMap,+               mi_arg_docs    = emptyArgDocMap,+               mi_final_exts        = () }++emptyFullModIface :: Module -> ModIface+emptyFullModIface mod =+    (emptyPartialModIface mod)+      { mi_decls = []+      , mi_final_exts = ModIfaceBackend+        { mi_iface_hash = fingerprint0,+          mi_mod_hash = fingerprint0,+          mi_flag_hash = fingerprint0,+          mi_opt_hash = fingerprint0,+          mi_hpc_hash = fingerprint0,+          mi_plugin_hash = fingerprint0,+          mi_orphan = False,+          mi_finsts = False,+          mi_exp_hash = fingerprint0,+          mi_orphan_hash = fingerprint0,+          mi_warn_fn = emptyIfaceWarnCache,+          mi_fix_fn = emptyIfaceFixCache,+          mi_hash_fn = emptyIfaceHashCache } }++-- | Constructs cache for the 'mi_hash_fn' field of a 'ModIface'+mkIfaceHashCache :: [(Fingerprint,IfaceDecl)]+                 -> (OccName -> Maybe (OccName, Fingerprint))+mkIfaceHashCache pairs+  = \occ -> lookupOccEnv env occ+  where+    env = foldl' add_decl emptyOccEnv pairs+    add_decl env0 (v,d) = foldl' add env0 (ifaceDeclFingerprints v d)+      where+        add env0 (occ,hash) = extendOccEnv env0 occ (occ,hash)++emptyIfaceHashCache :: OccName -> Maybe (OccName, Fingerprint)+emptyIfaceHashCache _occ = Nothing+++-- | The 'ModDetails' is essentially a cache for information in the 'ModIface'+-- for home modules only. Information relating to packages will be loaded into+-- global environments in 'ExternalPackageState'.+data ModDetails+  = ModDetails {+        -- The next two fields are created by the typechecker+        md_exports   :: [AvailInfo],+        md_types     :: !TypeEnv,       -- ^ Local type environment for this particular module+                                        -- Includes Ids, TyCons, PatSyns+        md_insts     :: ![ClsInst],     -- ^ 'DFunId's for the instances in this module+        md_fam_insts :: ![FamInst],+        md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules+        md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently+                                        -- they only annotate things also declared in this module+        md_complete_sigs :: [CompleteMatch]+          -- ^ Complete match pragmas for this module+     }++-- | Constructs an empty ModDetails+emptyModDetails :: ModDetails+emptyModDetails+  = ModDetails { md_types     = emptyTypeEnv,+                 md_exports   = [],+                 md_insts     = [],+                 md_rules     = [],+                 md_fam_insts = [],+                 md_anns      = [],+                 md_complete_sigs = [] }++-- | Records the modules directly imported by a module for extracting e.g.+-- usage information, and also to give better error message+type ImportedMods = ModuleEnv [ImportedBy]++-- | If a module was "imported" by the user, we associate it with+-- more detailed usage information 'ImportedModsVal'; a module+-- imported by the system only gets used for usage information.+data ImportedBy+    = ImportedByUser ImportedModsVal+    | ImportedBySystem++importedByUser :: [ImportedBy] -> [ImportedModsVal]+importedByUser (ImportedByUser imv : bys) = imv : importedByUser bys+importedByUser (ImportedBySystem   : bys) =       importedByUser bys+importedByUser [] = []++data ImportedModsVal+ = ImportedModsVal {+        imv_name :: ModuleName,          -- ^ The name the module is imported with+        imv_span :: SrcSpan,             -- ^ the source span of the whole import+        imv_is_safe :: IsSafeImport,     -- ^ whether this is a safe import+        imv_is_hiding :: Bool,           -- ^ whether this is an "hiding" import+        imv_all_exports :: !GlobalRdrEnv, -- ^ all the things the module could provide+          -- NB. BangPattern here: otherwise this leaks. (#15111)+        imv_qualified :: Bool            -- ^ whether this is a qualified import+        }++-- | A ModGuts is carried through the compiler, accumulating stuff as it goes+-- There is only one ModGuts at any time, the one for the module+-- being compiled right now.  Once it is compiled, a 'ModIface' and+-- 'ModDetails' are extracted and the ModGuts is discarded.+data ModGuts+  = ModGuts {+        mg_module    :: !Module,         -- ^ Module being compiled+        mg_hsc_src   :: HscSource,       -- ^ Whether it's an hs-boot module+        mg_loc       :: SrcSpan,         -- ^ For error messages from inner passes+        mg_exports   :: ![AvailInfo],    -- ^ What it exports+        mg_deps      :: !Dependencies,   -- ^ What it depends on, directly or+                                         -- otherwise+        mg_usages    :: ![Usage],        -- ^ What was used?  Used for interfaces.++        mg_used_th   :: !Bool,           -- ^ Did we run a TH splice?+        mg_rdr_env   :: !GlobalRdrEnv,   -- ^ Top-level lexical environment++        -- These fields all describe the things **declared in this module**+        mg_fix_env   :: !FixityEnv,      -- ^ Fixities declared in this module.+                                         -- Used for creating interface files.+        mg_tcs       :: ![TyCon],        -- ^ TyCons declared in this module+                                         -- (includes TyCons for classes)+        mg_insts     :: ![ClsInst],      -- ^ Class instances declared in this module+        mg_fam_insts :: ![FamInst],+                                         -- ^ Family instances declared in this module+        mg_patsyns   :: ![PatSyn],       -- ^ Pattern synonyms declared in this module+        mg_rules     :: ![CoreRule],     -- ^ Before the core pipeline starts, contains+                                         -- See Note [Overall plumbing for rules] in GHC.Core.Rules+        mg_binds     :: !CoreProgram,    -- ^ Bindings for this module+        mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module+        mg_foreign_files :: ![(ForeignSrcLang, FilePath)],+        -- ^ Files to be compiled with the C compiler+        mg_warns     :: !Warnings,       -- ^ Warnings declared in the module+        mg_anns      :: [Annotation],    -- ^ Annotations declared in this module+        mg_complete_sigs :: [CompleteMatch], -- ^ Complete Matches+        mg_hpc_info  :: !HpcInfo,        -- ^ Coverage tick boxes in the module+        mg_modBreaks :: !(Maybe ModBreaks), -- ^ Breakpoints for the module++                        -- The next two fields are unusual, because they give instance+                        -- environments for *all* modules in the home package, including+                        -- this module, rather than for *just* this module.+                        -- Reason: when looking up an instance we don't want to have to+                        --         look at each module in the home package in turn+        mg_inst_env     :: InstEnv,             -- ^ Class instance environment for+                                                -- /home-package/ modules (including this+                                                -- one); c.f. 'tcg_inst_env'+        mg_fam_inst_env :: FamInstEnv,          -- ^ Type-family instance environment for+                                                -- /home-package/ modules (including this+                                                -- one); c.f. 'tcg_fam_inst_env'++        mg_safe_haskell :: SafeHaskellMode,     -- ^ Safe Haskell mode+        mg_trust_pkg    :: Bool,                -- ^ Do we need to trust our+                                                -- own package for Safe Haskell?+                                                -- See Note [Trust Own Package]+                                                -- in GHC.Rename.Names++        mg_doc_hdr       :: !(Maybe HsDocString), -- ^ Module header.+        mg_decl_docs     :: !DeclDocMap,     -- ^ Docs on declarations.+        mg_arg_docs      :: !ArgDocMap       -- ^ Docs on arguments.+    }++-- The ModGuts takes on several slightly different forms:+--+-- After simplification, the following fields change slightly:+--      mg_rules        Orphan rules only (local ones now attached to binds)+--      mg_binds        With rules attached++---------------------------------------------------------+-- The Tidy pass forks the information about this module:+--      * one lot goes to interface file generation (ModIface)+--        and later compilations (ModDetails)+--      * the other lot goes to code generation (CgGuts)++-- | A restricted form of 'ModGuts' for code generation purposes+data CgGuts+  = CgGuts {+        cg_module    :: !Module,+                -- ^ Module being compiled++        cg_tycons    :: [TyCon],+                -- ^ Algebraic data types (including ones that started+                -- life as classes); generate constructors and info+                -- tables. Includes newtypes, just for the benefit of+                -- External Core++        cg_binds     :: CoreProgram,+                -- ^ The tidied main bindings, including+                -- previously-implicit bindings for record and class+                -- selectors, and data constructor wrappers.  But *not*+                -- data constructor workers; reason: we regard them+                -- as part of the code-gen of tycons++        cg_foreign   :: !ForeignStubs,   -- ^ Foreign export stubs+        cg_foreign_files :: ![(ForeignSrcLang, FilePath)],+        cg_dep_pkgs  :: ![InstalledUnitId], -- ^ Dependent packages, used to+                                            -- generate #includes for C code gen+        cg_hpc_info  :: !HpcInfo,           -- ^ Program coverage tick box information+        cg_modBreaks :: !(Maybe ModBreaks), -- ^ Module breakpoints+        cg_spt_entries :: [SptEntry]+                -- ^ Static pointer table entries for static forms defined in+                -- the module.+                -- See Note [Grand plan for static forms] in StaticPtrTable+    }++-----------------------------------+-- | Foreign export stubs+data ForeignStubs+  = NoStubs+      -- ^ We don't have any stubs+  | ForeignStubs SDoc SDoc+      -- ^ There are some stubs. Parameters:+      --+      --  1) Header file prototypes for+      --     "foreign exported" functions+      --+      --  2) C stubs to use when calling+      --     "foreign exported" functions++appendStubC :: ForeignStubs -> SDoc -> ForeignStubs+appendStubC NoStubs            c_code = ForeignStubs empty c_code+appendStubC (ForeignStubs h c) c_code = ForeignStubs h (c $$ c_code)++{-+************************************************************************+*                                                                      *+                The interactive context+*                                                                      *+************************************************************************++Note [The interactive package]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Type, class, and value declarations at the command prompt are treated+as if they were defined in modules+   interactive:Ghci1+   interactive:Ghci2+   ...etc...+with each bunch of declarations using a new module, all sharing a+common package 'interactive' (see Module.interactiveUnitId, and+PrelNames.mkInteractiveModule).++This scheme deals well with shadowing.  For example:++   ghci> data T = A+   ghci> data T = B+   ghci> :i A+   data Ghci1.T = A  -- Defined at <interactive>:2:10++Here we must display info about constructor A, but its type T has been+shadowed by the second declaration.  But it has a respectable+qualified name (Ghci1.T), and its source location says where it was+defined.++So the main invariant continues to hold, that in any session an+original name M.T only refers to one unique thing.  (In a previous+iteration both the T's above were called :Interactive.T, albeit with+different uniques, which gave rise to all sorts of trouble.)++The details are a bit tricky though:++ * The field ic_mod_index counts which Ghci module we've got up to.+   It is incremented when extending ic_tythings++ * ic_tythings contains only things from the 'interactive' package.++ * Module from the 'interactive' package (Ghci1, Ghci2 etc) never go+   in the Home Package Table (HPT).  When you say :load, that's when we+   extend the HPT.++ * The 'thisPackage' field of DynFlags is *not* set to 'interactive'.+   It stays as 'main' (or whatever -this-unit-id says), and is the+   package to which :load'ed modules are added to.++ * So how do we arrange that declarations at the command prompt get to+   be in the 'interactive' package?  Simply by setting the tcg_mod+   field of the TcGblEnv to "interactive:Ghci1".  This is done by the+   call to initTc in initTcInteractive, which in turn get the module+   from it 'icInteractiveModule' field of the interactive context.++   The 'thisPackage' field stays as 'main' (or whatever -this-unit-id says.++ * The main trickiness is that the type environment (tcg_type_env) and+   fixity envt (tcg_fix_env), now contain entities from all the+   interactive-package modules (Ghci1, Ghci2, ...) together, rather+   than just a single module as is usually the case.  So you can't use+   "nameIsLocalOrFrom" to decide whether to look in the TcGblEnv vs+   the HPT/PTE.  This is a change, but not a problem provided you+   know.++* However, the tcg_binds, tcg_sigs, tcg_insts, tcg_fam_insts, etc fields+  of the TcGblEnv, which collect "things defined in this module", all+  refer to stuff define in a single GHCi command, *not* all the commands+  so far.++  In contrast, tcg_inst_env, tcg_fam_inst_env, have instances from+  all GhciN modules, which makes sense -- they are all "home package"+  modules.+++Note [Interactively-bound Ids in GHCi]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The Ids bound by previous Stmts in GHCi are currently+        a) GlobalIds, with+        b) An External Name, like Ghci4.foo+           See Note [The interactive package] above+        c) A tidied type++ (a) They must be GlobalIds (not LocalIds) otherwise when we come to+     compile an expression using these ids later, the byte code+     generator will consider the occurrences to be free rather than+     global.++ (b) Having an External Name is important because of Note+     [GlobalRdrEnv shadowing] in RdrName++ (c) Their types are tidied. This is important, because :info may ask+     to look at them, and :info expects the things it looks up to have+     tidy types++Where do interactively-bound Ids come from?++  - GHCi REPL Stmts   e.g.+         ghci> let foo x = x+1+    These start with an Internal Name because a Stmt is a local+    construct, so the renamer naturally builds an Internal name for+    each of its binders.  Then in tcRnStmt they are externalised via+    TcRnDriver.externaliseAndTidyId, so they get Names like Ghic4.foo.++  - Ids bound by the debugger etc have Names constructed by+    GHC.Iface.Env.newInteractiveBinder; at the call sites it is followed by+    mkVanillaGlobal or mkVanillaGlobalWithInfo.  So again, they are+    all Global, External.++  - TyCons, Classes, and Ids bound by other top-level declarations in+    GHCi (eg foreign import, record selectors) also get External+    Names, with Ghci9 (or 8, or 7, etc) as the module name.+++Note [ic_tythings]+~~~~~~~~~~~~~~~~~~+The ic_tythings field contains+  * The TyThings declared by the user at the command prompt+    (eg Ids, TyCons, Classes)++  * The user-visible Ids that arise from such things, which+    *don't* come from 'implicitTyThings', notably:+       - record selectors+       - class ops+    The implicitTyThings are readily obtained from the TyThings+    but record selectors etc are not++It does *not* contain+  * DFunIds (they can be gotten from ic_instances)+  * CoAxioms (ditto)++See also Note [Interactively-bound Ids in GHCi]++Note [Override identical instances in GHCi]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If you declare a new instance in GHCi that is identical to a previous one,+we simply override the previous one; we don't regard it as overlapping.+e.g.    Prelude> data T = A | B+        Prelude> instance Eq T where ...+        Prelude> instance Eq T where ...   -- This one overrides++It's exactly the same for type-family instances.  See #7102+-}++-- | Interactive context, recording information about the state of the+-- context in which statements are executed in a GHCi session.+data InteractiveContext+  = InteractiveContext {+         ic_dflags     :: DynFlags,+             -- ^ The 'DynFlags' used to evaluate interactive expressions+             -- and statements.++         ic_mod_index :: Int,+             -- ^ Each GHCi stmt or declaration brings some new things into+             -- scope. We give them names like interactive:Ghci9.T,+             -- where the ic_index is the '9'.  The ic_mod_index is+             -- incremented whenever we add something to ic_tythings+             -- See Note [The interactive package]++         ic_imports :: [InteractiveImport],+             -- ^ The GHCi top-level scope (ic_rn_gbl_env) is extended with+             -- these imports+             --+             -- This field is only stored here so that the client+             -- can retrieve it with GHC.getContext. GHC itself doesn't+             -- use it, but does reset it to empty sometimes (such+             -- as before a GHC.load). The context is set with GHC.setContext.++         ic_tythings   :: [TyThing],+             -- ^ TyThings defined by the user, in reverse order of+             -- definition (ie most recent at the front)+             -- See Note [ic_tythings]++         ic_rn_gbl_env :: GlobalRdrEnv,+             -- ^ The cached 'GlobalRdrEnv', built by+             -- 'GHC.Runtime.Eval.setContext' and updated regularly+             -- It contains everything in scope at the command line,+             -- including everything in ic_tythings++         ic_instances  :: ([ClsInst], [FamInst]),+             -- ^ All instances and family instances created during+             -- this session.  These are grabbed en masse after each+             -- update to be sure that proper overlapping is retained.+             -- That is, rather than re-check the overlapping each+             -- time we update the context, we just take the results+             -- from the instance code that already does that.++         ic_fix_env :: FixityEnv,+            -- ^ Fixities declared in let statements++         ic_default :: Maybe [Type],+             -- ^ The current default types, set by a 'default' declaration++          ic_resume :: [Resume],+             -- ^ The stack of breakpoint contexts++         ic_monad      :: Name,+             -- ^ The monad that GHCi is executing in++         ic_int_print  :: Name,+             -- ^ The function that is used for printing results+             -- of expressions in ghci and -e mode.++         ic_cwd :: Maybe FilePath+             -- virtual CWD of the program+    }++data InteractiveImport+  = IIDecl (ImportDecl GhcPs)+      -- ^ Bring the exports of a particular module+      -- (filtered by an import decl) into scope++  | IIModule ModuleName+      -- ^ Bring into scope the entire top-level envt of+      -- of this module, including the things imported+      -- into it.+++-- | Constructs an empty InteractiveContext.+emptyInteractiveContext :: DynFlags -> InteractiveContext+emptyInteractiveContext dflags+  = InteractiveContext {+       ic_dflags     = dflags,+       ic_imports    = [],+       ic_rn_gbl_env = emptyGlobalRdrEnv,+       ic_mod_index  = 1,+       ic_tythings   = [],+       ic_instances  = ([],[]),+       ic_fix_env    = emptyNameEnv,+       ic_monad      = ioTyConName,  -- IO monad by default+       ic_int_print  = printName,    -- System.IO.print by default+       ic_default    = Nothing,+       ic_resume     = [],+       ic_cwd        = Nothing }++icInteractiveModule :: InteractiveContext -> Module+icInteractiveModule (InteractiveContext { ic_mod_index = index })+  = mkInteractiveModule index++-- | This function returns the list of visible TyThings (useful for+-- e.g. showBindings)+icInScopeTTs :: InteractiveContext -> [TyThing]+icInScopeTTs = ic_tythings++-- | Get the PrintUnqualified function based on the flags and this InteractiveContext+icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified+icPrintUnqual dflags InteractiveContext{ ic_rn_gbl_env = grenv } =+    mkPrintUnqualified dflags grenv++-- | extendInteractiveContext is called with new TyThings recently defined to update the+-- InteractiveContext to include them.  Ids are easily removed when shadowed,+-- but Classes and TyCons are not.  Some work could be done to determine+-- whether they are entirely shadowed, but as you could still have references+-- to them (e.g. instances for classes or values of the type for TyCons), it's+-- not clear whether removing them is even the appropriate behavior.+extendInteractiveContext :: InteractiveContext+                         -> [TyThing]+                         -> [ClsInst] -> [FamInst]+                         -> Maybe [Type]+                         -> FixityEnv+                         -> InteractiveContext+extendInteractiveContext ictxt new_tythings new_cls_insts new_fam_insts defaults fix_env+  = ictxt { ic_mod_index  = ic_mod_index ictxt + 1+                            -- Always bump this; even instances should create+                            -- a new mod_index (#9426)+          , ic_tythings   = new_tythings ++ old_tythings+          , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings+          , ic_instances  = ( new_cls_insts ++ old_cls_insts+                            , new_fam_insts ++ fam_insts )+                            -- we don't shadow old family instances (#7102),+                            -- so don't need to remove them here+          , ic_default    = defaults+          , ic_fix_env    = fix_env  -- See Note [Fixity declarations in GHCi]+          }+  where+    new_ids = [id | AnId id <- new_tythings]+    old_tythings = filterOut (shadowed_by new_ids) (ic_tythings ictxt)++    -- Discard old instances that have been fully overridden+    -- See Note [Override identical instances in GHCi]+    (cls_insts, fam_insts) = ic_instances ictxt+    old_cls_insts = filterOut (\i -> any (identicalClsInstHead i) new_cls_insts) cls_insts++extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext+-- Just a specialised version+extendInteractiveContextWithIds ictxt new_ids+  | null new_ids = ictxt+  | otherwise    = ictxt { ic_mod_index  = ic_mod_index ictxt + 1+                         , ic_tythings   = new_tythings ++ old_tythings+                         , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings }+  where+    new_tythings = map AnId new_ids+    old_tythings = filterOut (shadowed_by new_ids) (ic_tythings ictxt)++shadowed_by :: [Id] -> TyThing -> Bool+shadowed_by ids = shadowed+  where+    shadowed id = getOccName id `elemOccSet` new_occs+    new_occs = mkOccSet (map getOccName ids)++setInteractivePackage :: HscEnv -> HscEnv+-- Set the 'thisPackage' DynFlag to 'interactive'+setInteractivePackage hsc_env+   = hsc_env { hsc_dflags = (hsc_dflags hsc_env)+                { thisInstalledUnitId = toInstalledUnitId interactiveUnitId } }++setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext+setInteractivePrintName ic n = ic{ic_int_print = n}++    -- ToDo: should not add Ids to the gbl env here++-- | Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing+-- later ones, and shadowing existing entries in the GlobalRdrEnv.+icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv+icExtendGblRdrEnv env tythings+  = foldr add env tythings  -- Foldr makes things in the front of+                            -- the list shadow things at the back+  where+    -- One at a time, to ensure each shadows the previous ones+    add thing env+       | is_sub_bndr thing+       = env+       | otherwise+       = foldl' extendGlobalRdrEnv env1 (concatMap localGREsFromAvail avail)+       where+          env1  = shadowNames env (concatMap availNames avail)+          avail = tyThingAvailInfo thing++    -- Ugh! The new_tythings may include record selectors, since they+    -- are not implicit-ids, and must appear in the TypeEnv.  But they+    -- will also be brought into scope by the corresponding (ATyCon+    -- tc).  And we want the latter, because that has the correct+    -- parent (#10520)+    is_sub_bndr (AnId f) = case idDetails f of+                             RecSelId {}  -> True+                             ClassOpId {} -> True+                             _            -> False+    is_sub_bndr _ = False++substInteractiveContext :: InteractiveContext -> TCvSubst -> InteractiveContext+substInteractiveContext ictxt@InteractiveContext{ ic_tythings = tts } subst+  | isEmptyTCvSubst subst = ictxt+  | otherwise             = ictxt { ic_tythings = map subst_ty tts }+  where+    subst_ty (AnId id)+      = AnId $ id `setIdType` substTyAddInScope subst (idType id)+      -- Variables in the interactive context *can* mention free type variables+      -- because of the runtime debugger. Otherwise you'd expect all+      -- variables bound in the interactive context to be closed.+    subst_ty tt+      = tt++instance Outputable InteractiveImport where+  ppr (IIModule m) = char '*' <> ppr m+  ppr (IIDecl d)   = ppr d++{-+************************************************************************+*                                                                      *+        Building a PrintUnqualified+*                                                                      *+************************************************************************++Note [Printing original names]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Deciding how to print names is pretty tricky.  We are given a name+P:M.T, where P is the package name, M is the defining module, and T is+the occurrence name, and we have to decide in which form to display+the name given a GlobalRdrEnv describing the current scope.++Ideally we want to display the name in the form in which it is in+scope.  However, the name might not be in scope at all, and that's+where it gets tricky.  Here are the cases:++ 1. T uniquely maps to  P:M.T      --->  "T"      NameUnqual+ 2. There is an X for which X.T+       uniquely maps to  P:M.T     --->  "X.T"    NameQual X+ 3. There is no binding for "M.T"  --->  "M.T"    NameNotInScope1+ 4. Otherwise                      --->  "P:M.T"  NameNotInScope2++(3) and (4) apply when the entity P:M.T is not in the GlobalRdrEnv at+all. In these cases we still want to refer to the name as "M.T", *but*+"M.T" might mean something else in the current scope (e.g. if there's+an "import X as M"), so to avoid confusion we avoid using "M.T" if+there's already a binding for it.  Instead we write P:M.T.++There's one further subtlety: in case (3), what if there are two+things around, P1:M.T and P2:M.T?  Then we don't want to print both of+them as M.T!  However only one of the modules P1:M and P2:M can be+exposed (say P2), so we use M.T for that, and P1:M.T for the other one.+This is handled by the qual_mod component of PrintUnqualified, inside+the (ppr mod) of case (3), in Name.pprModulePrefix++Note [Printing unit ids]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In the old days, original names were tied to PackageIds, which directly+corresponded to the entities that users wrote in Cabal files, and were perfectly+suitable for printing when we need to disambiguate packages.  However, with+UnitId, the situation can be different: if the key is instantiated with+some holes, we should try to give the user some more useful information.+-}++-- | Creates some functions that work out the best ways to format+-- names for the user according to a set of heuristics.+mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified+mkPrintUnqualified dflags env = QueryQualify qual_name+                                             (mkQualModule dflags)+                                             (mkQualPackage dflags)+  where+  qual_name mod occ+        | [gre] <- unqual_gres+        , right_name gre+        = NameUnqual   -- If there's a unique entity that's in scope+                       -- unqualified with 'occ' AND that entity is+                       -- the right one, then we can use the unqualified name++        | [] <- unqual_gres+        , any is_name forceUnqualNames+        , not (isDerivedOccName occ)+        = NameUnqual   -- Don't qualify names that come from modules+                       -- that come with GHC, often appear in error messages,+                       -- but aren't typically in scope. Doing this does not+                       -- cause ambiguity, and it reduces the amount of+                       -- qualification in error messages thus improving+                       -- readability.+                       --+                       -- A motivating example is 'Constraint'. It's often not+                       -- in scope, but printing GHC.Prim.Constraint seems+                       -- overkill.++        | [gre] <- qual_gres+        = NameQual (greQualModName gre)++        | null qual_gres+        = if null (lookupGRE_RdrName (mkRdrQual (moduleName mod) occ) env)+          then NameNotInScope1+          else NameNotInScope2++        | otherwise+        = NameNotInScope1   -- Can happen if 'f' is bound twice in the module+                            -- Eg  f = True; g = 0; f = False+      where+        is_name :: Name -> Bool+        is_name name = ASSERT2( isExternalName name, ppr name )+                       nameModule name == mod && nameOccName name == occ++        forceUnqualNames :: [Name]+        forceUnqualNames =+          map tyConName [ constraintKindTyCon, heqTyCon, coercibleTyCon ]+          ++ [ eqTyConName ]++        right_name gre = nameModule_maybe (gre_name gre) == Just mod++        unqual_gres = lookupGRE_RdrName (mkRdrUnqual occ) env+        qual_gres   = filter right_name (lookupGlobalRdrEnv env occ)++    -- we can mention a module P:M without the P: qualifier iff+    -- "import M" would resolve unambiguously to P:M.  (if P is the+    -- current package we can just assume it is unqualified).++-- | Creates a function for formatting modules based on two heuristics:+-- (1) if the module is the current module, don't qualify, and (2) if there+-- is only one exposed package which exports this module, don't qualify.+mkQualModule :: DynFlags -> QueryQualifyModule+mkQualModule dflags mod+     | moduleUnitId mod == thisPackage dflags = False++     | [(_, pkgconfig)] <- lookup,+       packageConfigId pkgconfig == moduleUnitId mod+        -- this says: we are given a module P:M, is there just one exposed package+        -- that exposes a module M, and is it package P?+     = False++     | otherwise = True+     where lookup = lookupModuleInAllPackages dflags (moduleName mod)++-- | Creates a function for formatting packages based on two heuristics:+-- (1) don't qualify if the package in question is "main", and (2) only qualify+-- with a unit id if the package ID would be ambiguous.+mkQualPackage :: DynFlags -> QueryQualifyPackage+mkQualPackage dflags uid+     | uid == mainUnitId || uid == interactiveUnitId+        -- Skip the lookup if it's main, since it won't be in the package+        -- database!+     = False+     | Just pkgid <- mb_pkgid+     , searchPackageId dflags pkgid `lengthIs` 1+        -- this says: we are given a package pkg-0.1@MMM, are there only one+        -- exposed packages whose package ID is pkg-0.1?+     = False+     | otherwise+     = True+     where mb_pkgid = fmap sourcePackageId (lookupUnit dflags uid)++-- | A function which only qualifies package names if necessary; but+-- qualifies all other identifiers.+pkgQual :: DynFlags -> PrintUnqualified+pkgQual dflags = alwaysQualify {+        queryQualifyPackage = mkQualPackage dflags+    }++{-+************************************************************************+*                                                                      *+                Implicit TyThings+*                                                                      *+************************************************************************++Note [Implicit TyThings]+~~~~~~~~~~~~~~~~~~~~~~~~+  DEFINITION: An "implicit" TyThing is one that does not have its own+  IfaceDecl in an interface file.  Instead, its binding in the type+  environment is created as part of typechecking the IfaceDecl for+  some other thing.++Examples:+  * All DataCons are implicit, because they are generated from the+    IfaceDecl for the data/newtype.  Ditto class methods.++  * Record selectors are *not* implicit, because they get their own+    free-standing IfaceDecl.++  * Associated data/type families are implicit because they are+    included in the IfaceDecl of the parent class.  (NB: the+    IfaceClass decl happens to use IfaceDecl recursively for the+    associated types, but that's irrelevant here.)++  * Dictionary function Ids are not implicit.++  * Axioms for newtypes are implicit (same as above), but axioms+    for data/type family instances are *not* implicit (like DFunIds).+-}++-- | Determine the 'TyThing's brought into scope by another 'TyThing'+-- /other/ than itself. For example, Id's don't have any implicit TyThings+-- as they just bring themselves into scope, but classes bring their+-- dictionary datatype, type constructor and some selector functions into+-- scope, just for a start!++-- N.B. the set of TyThings returned here *must* match the set of+-- names returned by GHC.Iface.Load.ifaceDeclImplicitBndrs, in the sense that+-- TyThing.getOccName should define a bijection between the two lists.+-- This invariant is used in GHC.Iface.Load.loadDecl (see note [Tricky iface loop])+-- The order of the list does not matter.+implicitTyThings :: TyThing -> [TyThing]+implicitTyThings (AnId _)       = []+implicitTyThings (ACoAxiom _cc) = []+implicitTyThings (ATyCon tc)    = implicitTyConThings tc+implicitTyThings (AConLike cl)  = implicitConLikeThings cl++implicitConLikeThings :: ConLike -> [TyThing]+implicitConLikeThings (RealDataCon dc)+  = dataConImplicitTyThings dc++implicitConLikeThings (PatSynCon {})+  = []  -- Pattern synonyms have no implicit Ids; the wrapper and matcher+        -- are not "implicit"; they are simply new top-level bindings,+        -- and they have their own declaration in an interface file+        -- Unless a record pat syn when there are implicit selectors+        -- They are still not included here as `implicitConLikeThings` is+        -- used by `tcTyClsDecls` whilst pattern synonyms are typed checked+        -- by `tcTopValBinds`.++implicitClassThings :: Class -> [TyThing]+implicitClassThings cl+  = -- Does not include default methods, because those Ids may have+    --    their own pragmas, unfoldings etc, not derived from the Class object++    -- associated types+    --    No recursive call for the classATs, because they+    --    are only the family decls; they have no implicit things+    map ATyCon (classATs cl) ++++    -- superclass and operation selectors+    map AnId (classAllSelIds cl)++implicitTyConThings :: TyCon -> [TyThing]+implicitTyConThings tc+  = class_stuff +++      -- fields (names of selectors)++      -- (possibly) implicit newtype axioms+      -- or type family axioms+    implicitCoTyCon tc ++++      -- for each data constructor in order,+      --   the constructor, worker, and (possibly) wrapper+    [ thing | dc    <- tyConDataCons tc+            , thing <- AConLike (RealDataCon dc) : dataConImplicitTyThings dc ]+      -- NB. record selectors are *not* implicit, they have fully-fledged+      -- bindings that pass through the compilation pipeline as normal.+  where+    class_stuff = case tyConClass_maybe tc of+        Nothing -> []+        Just cl -> implicitClassThings cl++-- For newtypes and closed type families (only) add the implicit coercion tycon+implicitCoTyCon :: TyCon -> [TyThing]+implicitCoTyCon tc+  | Just co <- newTyConCo_maybe tc = [ACoAxiom $ toBranchedAxiom co]+  | Just co <- isClosedSynFamilyTyConWithAxiom_maybe tc+                                   = [ACoAxiom co]+  | otherwise                      = []++-- | Returns @True@ if there should be no interface-file declaration+-- for this thing on its own: either it is built-in, or it is part+-- of some other declaration, or it is generated implicitly by some+-- other declaration.+isImplicitTyThing :: TyThing -> Bool+isImplicitTyThing (AConLike cl) = case cl of+                                    RealDataCon {} -> True+                                    PatSynCon {}   -> False+isImplicitTyThing (AnId id)     = isImplicitId id+isImplicitTyThing (ATyCon tc)   = isImplicitTyCon tc+isImplicitTyThing (ACoAxiom ax) = isImplicitCoAxiom ax++-- | tyThingParent_maybe x returns (Just p)+-- when pprTyThingInContext should print a declaration for p+-- (albeit with some "..." in it) when asked to show x+-- It returns the *immediate* parent.  So a datacon returns its tycon+-- but the tycon could be the associated type of a class, so it in turn+-- might have a parent.+tyThingParent_maybe :: TyThing -> Maybe TyThing+tyThingParent_maybe (AConLike cl) = case cl of+    RealDataCon dc  -> Just (ATyCon (dataConTyCon dc))+    PatSynCon{}     -> Nothing+tyThingParent_maybe (ATyCon tc)   = case tyConAssoc_maybe tc of+                                      Just tc -> Just (ATyCon tc)+                                      Nothing -> Nothing+tyThingParent_maybe (AnId id)     = case idDetails id of+                                      RecSelId { sel_tycon = RecSelData tc } ->+                                          Just (ATyCon tc)+                                      ClassOpId cls               ->+                                          Just (ATyCon (classTyCon cls))+                                      _other                      -> Nothing+tyThingParent_maybe _other = Nothing++tyThingsTyCoVars :: [TyThing] -> TyCoVarSet+tyThingsTyCoVars tts =+    unionVarSets $ map ttToVarSet tts+    where+        ttToVarSet (AnId id)     = tyCoVarsOfType $ idType id+        ttToVarSet (AConLike cl) = case cl of+            RealDataCon dc  -> tyCoVarsOfType $ dataConRepType dc+            PatSynCon{}     -> emptyVarSet+        ttToVarSet (ATyCon tc)+          = case tyConClass_maybe tc of+              Just cls -> (mkVarSet . fst . classTvsFds) cls+              Nothing  -> tyCoVarsOfType $ tyConKind tc+        ttToVarSet (ACoAxiom _)  = emptyVarSet++-- | The Names that a TyThing should bring into scope.  Used to build+-- the GlobalRdrEnv for the InteractiveContext.+tyThingAvailInfo :: TyThing -> [AvailInfo]+tyThingAvailInfo (ATyCon t)+   = case tyConClass_maybe t of+        Just c  -> [AvailTC n (n : map getName (classMethods c)+                                 ++ map getName (classATs c))+                             [] ]+             where n = getName c+        Nothing -> [AvailTC n (n : map getName dcs) flds]+             where n    = getName t+                   dcs  = tyConDataCons t+                   flds = tyConFieldLabels t+tyThingAvailInfo (AConLike (PatSynCon p))+  = map avail ((getName p) : map flSelector (patSynFieldLabels p))+tyThingAvailInfo t+   = [avail (getName t)]++{-+************************************************************************+*                                                                      *+                TypeEnv+*                                                                      *+************************************************************************+-}++-- | A map from 'Name's to 'TyThing's, constructed by typechecking+-- local declarations or interface files+type TypeEnv = NameEnv TyThing++emptyTypeEnv    :: TypeEnv+typeEnvElts     :: TypeEnv -> [TyThing]+typeEnvTyCons   :: TypeEnv -> [TyCon]+typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]+typeEnvIds      :: TypeEnv -> [Id]+typeEnvPatSyns  :: TypeEnv -> [PatSyn]+typeEnvDataCons :: TypeEnv -> [DataCon]+typeEnvClasses  :: TypeEnv -> [Class]+lookupTypeEnv   :: TypeEnv -> Name -> Maybe TyThing++emptyTypeEnv        = emptyNameEnv+typeEnvElts     env = nameEnvElts env+typeEnvTyCons   env = [tc | ATyCon tc   <- typeEnvElts env]+typeEnvCoAxioms env = [ax | ACoAxiom ax <- typeEnvElts env]+typeEnvIds      env = [id | AnId id     <- typeEnvElts env]+typeEnvPatSyns  env = [ps | AConLike (PatSynCon ps) <- typeEnvElts env]+typeEnvDataCons env = [dc | AConLike (RealDataCon dc) <- typeEnvElts env]+typeEnvClasses  env = [cl | tc <- typeEnvTyCons env,+                            Just cl <- [tyConClass_maybe tc]]++mkTypeEnv :: [TyThing] -> TypeEnv+mkTypeEnv things = extendTypeEnvList emptyTypeEnv things++mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv+mkTypeEnvWithImplicits things =+  mkTypeEnv things+    `plusNameEnv`+  mkTypeEnv (concatMap implicitTyThings things)++typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv+typeEnvFromEntities ids tcs famInsts =+  mkTypeEnv (   map AnId ids+             ++ map ATyCon all_tcs+             ++ concatMap implicitTyConThings all_tcs+             ++ map (ACoAxiom . toBranchedAxiom . famInstAxiom) famInsts+            )+ where+  all_tcs = tcs ++ famInstsRepTyCons famInsts++lookupTypeEnv = lookupNameEnv++-- Extend the type environment+extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv+extendTypeEnv env thing = extendNameEnv env (getName thing) thing++extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv+extendTypeEnvList env things = foldl' extendTypeEnv env things++extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv+extendTypeEnvWithIds env ids+  = extendNameEnvList env [(getName id, AnId id) | id <- ids]++plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv+plusTypeEnv env1 env2 = plusNameEnv env1 env2++-- | Find the 'TyThing' for the given 'Name' by using all the resources+-- at our disposal: the compiled modules in the 'HomePackageTable' and the+-- compiled modules in other packages that live in 'PackageTypeEnv'. Note+-- that this does NOT look up the 'TyThing' in the module being compiled: you+-- have to do that yourself, if desired+lookupType :: DynFlags+           -> HomePackageTable+           -> PackageTypeEnv+           -> Name+           -> Maybe TyThing++lookupType dflags hpt pte name+  | isOneShot (ghcMode dflags)  -- in one-shot, we don't use the HPT+  = lookupNameEnv pte name+  | otherwise+  = case lookupHptByModule hpt mod of+       Just hm -> lookupNameEnv (md_types (hm_details hm)) name+       Nothing -> lookupNameEnv pte name+  where+    mod = ASSERT2( isExternalName name, ppr name )+          if isHoleName name+            then mkModule (thisPackage dflags) (moduleName (nameModule name))+            else nameModule name++-- | As 'lookupType', but with a marginally easier-to-use interface+-- if you have a 'HscEnv'+lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)+lookupTypeHscEnv hsc_env name = do+    eps <- readIORef (hsc_EPS hsc_env)+    return $! lookupType dflags hpt (eps_PTE eps) name+  where+    dflags = hsc_dflags hsc_env+    hpt = hsc_HPT hsc_env++-- | Get the 'TyCon' from a 'TyThing' if it is a type constructor thing. Panics otherwise+tyThingTyCon :: HasDebugCallStack => TyThing -> TyCon+tyThingTyCon (ATyCon tc) = tc+tyThingTyCon other       = pprPanic "tyThingTyCon" (ppr other)++-- | Get the 'CoAxiom' from a 'TyThing' if it is a coercion axiom thing. Panics otherwise+tyThingCoAxiom :: HasDebugCallStack => TyThing -> CoAxiom Branched+tyThingCoAxiom (ACoAxiom ax) = ax+tyThingCoAxiom other         = pprPanic "tyThingCoAxiom" (ppr other)++-- | Get the 'DataCon' from a 'TyThing' if it is a data constructor thing. Panics otherwise+tyThingDataCon :: HasDebugCallStack => TyThing -> DataCon+tyThingDataCon (AConLike (RealDataCon dc)) = dc+tyThingDataCon other                       = pprPanic "tyThingDataCon" (ppr other)++-- | Get the 'ConLike' from a 'TyThing' if it is a data constructor thing.+-- Panics otherwise+tyThingConLike :: HasDebugCallStack => TyThing -> ConLike+tyThingConLike (AConLike dc) = dc+tyThingConLike other         = pprPanic "tyThingConLike" (ppr other)++-- | Get the 'Id' from a 'TyThing' if it is a id *or* data constructor thing. Panics otherwise+tyThingId :: HasDebugCallStack => TyThing -> Id+tyThingId (AnId id)                   = id+tyThingId (AConLike (RealDataCon dc)) = dataConWrapId dc+tyThingId other                       = pprPanic "tyThingId" (ppr other)++{-+************************************************************************+*                                                                      *+\subsection{MonadThings and friends}+*                                                                      *+************************************************************************+-}++-- | Class that abstracts out the common ability of the monads in GHC+-- to lookup a 'TyThing' in the monadic environment by 'Name'. Provides+-- a number of related convenience functions for accessing particular+-- kinds of 'TyThing'+class Monad m => MonadThings m where+        lookupThing :: Name -> m TyThing++        lookupId :: Name -> m Id+        lookupId = liftM tyThingId . lookupThing++        lookupDataCon :: Name -> m DataCon+        lookupDataCon = liftM tyThingDataCon . lookupThing++        lookupTyCon :: Name -> m TyCon+        lookupTyCon = liftM tyThingTyCon . lookupThing++-- Instance used in GHC.HsToCore.Quote+instance MonadThings m => MonadThings (ReaderT s m) where+  lookupThing = lift . lookupThing++{-+************************************************************************+*                                                                      *+\subsection{Auxiliary types}+*                                                                      *+************************************************************************++These types are defined here because they are mentioned in ModDetails,+but they are mostly elaborated elsewhere+-}++------------------ Warnings -------------------------+-- | Warning information for a module+data Warnings+  = NoWarnings                          -- ^ Nothing deprecated+  | WarnAll WarningTxt                  -- ^ Whole module deprecated+  | WarnSome [(OccName,WarningTxt)]     -- ^ Some specific things deprecated++     -- Only an OccName is needed because+     --    (1) a deprecation always applies to a binding+     --        defined in the module in which the deprecation appears.+     --    (2) deprecations are only reported outside the defining module.+     --        this is important because, otherwise, if we saw something like+     --+     --        {-# DEPRECATED f "" #-}+     --        f = ...+     --        h = f+     --        g = let f = undefined in f+     --+     --        we'd need more information than an OccName to know to say something+     --        about the use of f in h but not the use of the locally bound f in g+     --+     --        however, because we only report about deprecations from the outside,+     --        and a module can only export one value called f,+     --        an OccName suffices.+     --+     --        this is in contrast with fixity declarations, where we need to map+     --        a Name to its fixity declaration.+  deriving( Eq )++instance Binary Warnings where+    put_ bh NoWarnings     = putByte bh 0+    put_ bh (WarnAll t) = do+            putByte bh 1+            put_ bh t+    put_ bh (WarnSome ts) = do+            putByte bh 2+            put_ bh ts++    get bh = do+            h <- getByte bh+            case h of+              0 -> return NoWarnings+              1 -> do aa <- get bh+                      return (WarnAll aa)+              _ -> do aa <- get bh+                      return (WarnSome aa)++-- | Constructs the cache for the 'mi_warn_fn' field of a 'ModIface'+mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt+mkIfaceWarnCache NoWarnings  = \_ -> Nothing+mkIfaceWarnCache (WarnAll t) = \_ -> Just t+mkIfaceWarnCache (WarnSome pairs) = lookupOccEnv (mkOccEnv pairs)++emptyIfaceWarnCache :: OccName -> Maybe WarningTxt+emptyIfaceWarnCache _ = Nothing++plusWarns :: Warnings -> Warnings -> Warnings+plusWarns d NoWarnings = d+plusWarns NoWarnings d = d+plusWarns _ (WarnAll t) = WarnAll t+plusWarns (WarnAll t) _ = WarnAll t+plusWarns (WarnSome v1) (WarnSome v2) = WarnSome (v1 ++ v2)++-- | Creates cached lookup for the 'mi_fix_fn' field of 'ModIface'+mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity+mkIfaceFixCache pairs+  = \n -> lookupOccEnv env n+  where+   env = mkOccEnv pairs++emptyIfaceFixCache :: OccName -> Maybe Fixity+emptyIfaceFixCache _ = Nothing++-- | Fixity environment mapping names to their fixities+type FixityEnv = NameEnv FixItem++-- | Fixity information for an 'Name'. We keep the OccName in the range+-- so that we can generate an interface from it+data FixItem = FixItem OccName Fixity++instance Outputable FixItem where+  ppr (FixItem occ fix) = ppr fix <+> ppr occ++emptyFixityEnv :: FixityEnv+emptyFixityEnv = emptyNameEnv++lookupFixity :: FixityEnv -> Name -> Fixity+lookupFixity env n = case lookupNameEnv env n of+                        Just (FixItem _ fix) -> fix+                        Nothing         -> defaultFixity++{-+************************************************************************+*                                                                      *+\subsection{WhatsImported}+*                                                                      *+************************************************************************+-}++-- | Records whether a module has orphans. An \"orphan\" is one of:+--+-- * An instance declaration in a module other than the definition+--   module for one of the type constructors or classes in the instance head+--+-- * A transformation rule in a module other than the one defining+--   the function in the head of the rule+--+type WhetherHasOrphans   = Bool++-- | Does this module define family instances?+type WhetherHasFamInst = Bool++-- | Did this module originate from a *-boot file?+type IsBootInterface = Bool++-- | Dependency information about ALL modules and packages below this one+-- in the import hierarchy.+--+-- Invariant: the dependencies of a module @M@ never includes @M@.+--+-- Invariant: none of the lists contain duplicates.+data Dependencies+  = Deps { dep_mods   :: [(ModuleName, IsBootInterface)]+                        -- ^ All home-package modules transitively below this one+                        -- I.e. modules that this one imports, or that are in the+                        --      dep_mods of those directly-imported modules++         , dep_pkgs   :: [(InstalledUnitId, Bool)]+                        -- ^ All packages transitively below this module+                        -- I.e. packages to which this module's direct imports belong,+                        --      or that are in the dep_pkgs of those modules+                        -- The bool indicates if the package is required to be+                        -- trusted when the module is imported as a safe import+                        -- (Safe Haskell). See Note [Tracking Trust Transitively] in GHC.Rename.Names++         , dep_orphs  :: [Module]+                        -- ^ Transitive closure of orphan modules (whether+                        -- home or external pkg).+                        --+                        -- (Possible optimization: don't include family+                        -- instance orphans as they are anyway included in+                        -- 'dep_finsts'.  But then be careful about code+                        -- which relies on dep_orphs having the complete list!)+                        -- This does NOT include us, unlike 'imp_orphs'.++         , dep_finsts :: [Module]+                        -- ^ Transitive closure of depended upon modules which+                        -- contain family instances (whether home or external).+                        -- This is used by 'checkFamInstConsistency'.  This+                        -- does NOT include us, unlike 'imp_finsts'. See Note+                        -- [The type family instance consistency story].++         , dep_plgins :: [ModuleName]+                        -- ^ All the plugins used while compiling this module.+         }+  deriving( Eq )+        -- Equality used only for old/new comparison in GHC.Iface.Utils.addFingerprints+        -- See 'TcRnTypes.ImportAvails' for details on dependencies.++instance Binary Dependencies where+    put_ bh deps = do put_ bh (dep_mods deps)+                      put_ bh (dep_pkgs deps)+                      put_ bh (dep_orphs deps)+                      put_ bh (dep_finsts deps)+                      put_ bh (dep_plgins deps)++    get bh = do ms <- get bh+                ps <- get bh+                os <- get bh+                fis <- get bh+                pl <- get bh+                return (Deps { dep_mods = ms, dep_pkgs = ps, dep_orphs = os,+                               dep_finsts = fis, dep_plgins = pl })++noDependencies :: Dependencies+noDependencies = Deps [] [] [] [] []++-- | Records modules for which changes may force recompilation of this module+-- See wiki: https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidance+--+-- This differs from Dependencies.  A module X may be in the dep_mods of this+-- module (via an import chain) but if we don't use anything from X it won't+-- appear in our Usage+data Usage+  -- | Module from another package+  = UsagePackageModule {+        usg_mod      :: Module,+           -- ^ External package module depended on+        usg_mod_hash :: Fingerprint,+            -- ^ Cached module fingerprint+        usg_safe :: IsSafeImport+            -- ^ Was this module imported as a safe import+    }+  -- | Module from the current package+  | UsageHomeModule {+        usg_mod_name :: ModuleName,+            -- ^ Name of the module+        usg_mod_hash :: Fingerprint,+            -- ^ Cached module fingerprint+        usg_entities :: [(OccName,Fingerprint)],+            -- ^ Entities we depend on, sorted by occurrence name and fingerprinted.+            -- NB: usages are for parent names only, e.g. type constructors+            -- but not the associated data constructors.+        usg_exports  :: Maybe Fingerprint,+            -- ^ Fingerprint for the export list of this module,+            -- if we directly imported it (and hence we depend on its export list)+        usg_safe :: IsSafeImport+            -- ^ Was this module imported as a safe import+    }                                           -- ^ Module from the current package+  -- | A file upon which the module depends, e.g. a CPP #include, or using TH's+  -- 'addDependentFile'+  | UsageFile {+        usg_file_path  :: FilePath,+        -- ^ External file dependency. From a CPP #include or TH+        -- addDependentFile. Should be absolute.+        usg_file_hash  :: Fingerprint+        -- ^ 'Fingerprint' of the file contents.++        -- Note: We don't consider things like modification timestamps+        -- here, because there's no reason to recompile if the actual+        -- contents don't change.  This previously lead to odd+        -- recompilation behaviors; see #8114+  }+  -- | A requirement which was merged into this one.+  | UsageMergedRequirement {+        usg_mod :: Module,+        usg_mod_hash :: Fingerprint+  }+    deriving( Eq )+        -- The export list field is (Just v) if we depend on the export list:+        --      i.e. we imported the module directly, whether or not we+        --           enumerated the things we imported, or just imported+        --           everything+        -- We need to recompile if M's exports change, because+        -- if the import was    import M,       we might now have a name clash+        --                                      in the importing module.+        -- if the import was    import M(x)     M might no longer export x+        -- The only way we don't depend on the export list is if we have+        --                      import M()+        -- And of course, for modules that aren't imported directly we don't+        -- depend on their export lists++instance Binary Usage where+    put_ bh usg@UsagePackageModule{} = do+        putByte bh 0+        put_ bh (usg_mod usg)+        put_ bh (usg_mod_hash usg)+        put_ bh (usg_safe     usg)++    put_ bh usg@UsageHomeModule{} = do+        putByte bh 1+        put_ bh (usg_mod_name usg)+        put_ bh (usg_mod_hash usg)+        put_ bh (usg_exports  usg)+        put_ bh (usg_entities usg)+        put_ bh (usg_safe     usg)++    put_ bh usg@UsageFile{} = do+        putByte bh 2+        put_ bh (usg_file_path usg)+        put_ bh (usg_file_hash usg)++    put_ bh usg@UsageMergedRequirement{} = do+        putByte bh 3+        put_ bh (usg_mod      usg)+        put_ bh (usg_mod_hash usg)++    get bh = do+        h <- getByte bh+        case h of+          0 -> do+            nm    <- get bh+            mod   <- get bh+            safe  <- get bh+            return UsagePackageModule { usg_mod = nm, usg_mod_hash = mod, usg_safe = safe }+          1 -> do+            nm    <- get bh+            mod   <- get bh+            exps  <- get bh+            ents  <- get bh+            safe  <- get bh+            return UsageHomeModule { usg_mod_name = nm, usg_mod_hash = mod,+                     usg_exports = exps, usg_entities = ents, usg_safe = safe }+          2 -> do+            fp   <- get bh+            hash <- get bh+            return UsageFile { usg_file_path = fp, usg_file_hash = hash }+          3 -> do+            mod <- get bh+            hash <- get bh+            return UsageMergedRequirement { usg_mod = mod, usg_mod_hash = hash }+          i -> error ("Binary.get(Usage): " ++ show i)++{-+************************************************************************+*                                                                      *+                The External Package State+*                                                                      *+************************************************************************+-}++type PackageTypeEnv          = TypeEnv+type PackageRuleBase         = RuleBase+type PackageInstEnv          = InstEnv+type PackageFamInstEnv       = FamInstEnv+type PackageAnnEnv           = AnnEnv+type PackageCompleteMatchMap = CompleteMatchMap++-- | Information about other packages that we have slurped in by reading+-- their interface files+data ExternalPackageState+  = EPS {+        eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface)),+                -- ^ In OneShot mode (only), home-package modules+                -- accumulate in the external package state, and are+                -- sucked in lazily.  For these home-pkg modules+                -- (only) we need to record which are boot modules.+                -- We set this field after loading all the+                -- explicitly-imported interfaces, but before doing+                -- anything else+                --+                -- The 'ModuleName' part is not necessary, but it's useful for+                -- debug prints, and it's convenient because this field comes+                -- direct from 'TcRnTypes.imp_dep_mods'++        eps_PIT :: !PackageIfaceTable,+                -- ^ The 'ModIface's for modules in external packages+                -- whose interfaces we have opened.+                -- The declarations in these interface files are held in the+                -- 'eps_decls', 'eps_inst_env', 'eps_fam_inst_env' and 'eps_rules'+                -- fields of this record, not in the 'mi_decls' fields of the+                -- interface we have sucked in.+                --+                -- What /is/ in the PIT is:+                --+                -- * The Module+                --+                -- * Fingerprint info+                --+                -- * Its exports+                --+                -- * Fixities+                --+                -- * Deprecations and warnings++        eps_free_holes :: InstalledModuleEnv (UniqDSet ModuleName),+                -- ^ Cache for 'mi_free_holes'.  Ordinarily, we can rely on+                -- the 'eps_PIT' for this information, EXCEPT that when+                -- we do dependency analysis, we need to look at the+                -- 'Dependencies' of our imports to determine what their+                -- precise free holes are ('moduleFreeHolesPrecise').  We+                -- don't want to repeatedly reread in the interface+                -- for every import, so cache it here.  When the PIT+                -- gets filled in we can drop these entries.++        eps_PTE :: !PackageTypeEnv,+                -- ^ Result of typechecking all the external package+                -- interface files we have sucked in. The domain of+                -- the mapping is external-package modules++        eps_inst_env     :: !PackageInstEnv,   -- ^ The total 'InstEnv' accumulated+                                               -- from all the external-package modules+        eps_fam_inst_env :: !PackageFamInstEnv,-- ^ The total 'FamInstEnv' accumulated+                                               -- from all the external-package modules+        eps_rule_base    :: !PackageRuleBase,  -- ^ The total 'RuleEnv' accumulated+                                               -- from all the external-package modules+        eps_ann_env      :: !PackageAnnEnv,    -- ^ The total 'AnnEnv' accumulated+                                               -- from all the external-package modules+        eps_complete_matches :: !PackageCompleteMatchMap,+                                  -- ^ The total 'CompleteMatchMap' accumulated+                                  -- from all the external-package modules++        eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv), -- ^ The family instances accumulated from external+                                                         -- packages, keyed off the module that declared them++        eps_stats :: !EpsStats                 -- ^ Stastics about what was loaded from external packages+  }++-- | Accumulated statistics about what we are putting into the 'ExternalPackageState'.+-- \"In\" means stuff that is just /read/ from interface files,+-- \"Out\" means actually sucked in and type-checked+data EpsStats = EpsStats { n_ifaces_in+                         , n_decls_in, n_decls_out+                         , n_rules_in, n_rules_out+                         , n_insts_in, n_insts_out :: !Int }++addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats+-- ^ Add stats for one newly-read interface+addEpsInStats stats n_decls n_insts n_rules+  = stats { n_ifaces_in = n_ifaces_in stats + 1+          , n_decls_in  = n_decls_in stats + n_decls+          , n_insts_in  = n_insts_in stats + n_insts+          , n_rules_in  = n_rules_in stats + n_rules }++{-+Names in a NameCache are always stored as a Global, and have the SrcLoc+of their binding locations.++Actually that's not quite right.  When we first encounter the original+name, we might not be at its binding site (e.g. we are reading an+interface file); so we give it 'noSrcLoc' then.  Later, when we find+its binding site, we fix it up.+-}++updNameCache :: IORef NameCache+             -> (NameCache -> (NameCache, c))  -- The updating function+             -> IO c+updNameCache ncRef upd_fn+  = atomicModifyIORef' ncRef upd_fn++mkSOName :: Platform -> FilePath -> FilePath+mkSOName platform root+    = case platformOS platform of+      OSMinGW32 ->           root  <.> soExt platform+      _         -> ("lib" ++ root) <.> soExt platform++mkHsSOName :: Platform -> FilePath -> FilePath+mkHsSOName platform root = ("lib" ++ root) <.> soExt platform++soExt :: Platform -> FilePath+soExt platform+    = case platformOS platform of+      OSDarwin  -> "dylib"+      OSMinGW32 -> "dll"+      _         -> "so"++{-+************************************************************************+*                                                                      *+                The module graph and ModSummary type+        A ModSummary is a node in the compilation manager's+        dependency graph, and it's also passed to hscMain+*                                                                      *+************************************************************************+-}++-- | A ModuleGraph contains all the nodes from the home package (only).+-- There will be a node for each source module, plus a node for each hi-boot+-- module.+--+-- The graph is not necessarily stored in topologically-sorted order.  Use+-- 'GHC.topSortModuleGraph' and 'Digraph.flattenSCC' to achieve this.+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 = 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:+--+-- * A regular Haskell source module+-- * A hi-boot source module+--+data ModSummary+   = ModSummary {+        ms_mod          :: Module,+          -- ^ Identity of the module+        ms_hsc_src      :: HscSource,+          -- ^ The module source either plain Haskell or hs-boot+        ms_location     :: ModLocation,+          -- ^ Location of the various files belonging to the module+        ms_hs_date      :: UTCTime,+          -- ^ Timestamp of source file+        ms_obj_date     :: Maybe UTCTime,+          -- ^ Timestamp of object, if we have one+        ms_iface_date   :: Maybe UTCTime,+          -- ^ Timestamp of hi file, if we *only* are typechecking (it is+          -- 'Nothing' otherwise.+          -- See Note [Recompilation checking in -fno-code mode] and #9243+        ms_hie_date   :: Maybe UTCTime,+          -- ^ Timestamp of hie file, if we have one+        ms_srcimps      :: [(Maybe FastString, Located ModuleName)],+          -- ^ Source imports of the module+        ms_textual_imps :: [(Maybe FastString, Located ModuleName)],+          -- ^ Non-source imports of the module from the module *text*+        ms_parsed_mod   :: Maybe HsParsedModule,+          -- ^ The parsed, nonrenamed source, if we have it.  This is also+          -- used to support "inline module syntax" in Backpack files.+        ms_hspp_file    :: FilePath,+          -- ^ Filename of preprocessed source file+        ms_hspp_opts    :: DynFlags,+          -- ^ Cached flags from @OPTIONS@, @INCLUDE@ and @LANGUAGE@+          -- pragmas in the modules source code+        ms_hspp_buf     :: Maybe StringBuffer+          -- ^ The actual preprocessed source, if we have it+     }++ms_installed_mod :: ModSummary -> InstalledModule+ms_installed_mod = fst . splitModuleInsts . ms_mod++ms_mod_name :: ModSummary -> ModuleName+ms_mod_name = moduleName . ms_mod++ms_imps :: ModSummary -> [(Maybe FastString, Located ModuleName)]+ms_imps ms =+  ms_textual_imps ms +++  map mk_additional_import (dynFlagDependencies (ms_hspp_opts ms))+  where+    mk_additional_import mod_nm = (Nothing, noLoc mod_nm)++home_imps :: [(Maybe FastString, Located ModuleName)] -> [Located ModuleName]+home_imps imps = [ lmodname |  (mb_pkg, lmodname) <- imps,+                                  isLocal mb_pkg ]+  where isLocal Nothing = True+        isLocal (Just pkg) | pkg == fsLit "this" = True -- "this" is special+        isLocal _ = False++ms_home_allimps :: ModSummary -> [ModuleName]+ms_home_allimps ms = map unLoc (ms_home_srcimps ms ++ ms_home_imps ms)++-- | Like 'ms_home_imps', but for SOURCE imports.+ms_home_srcimps :: ModSummary -> [Located ModuleName]+ms_home_srcimps = home_imps . ms_srcimps++-- | All of the (possibly) home module imports from a+-- 'ModSummary'; that is to say, each of these module names+-- could be a home import if an appropriately named file+-- existed.  (This is in contrast to package qualified+-- imports, which are guaranteed not to be home imports.)+ms_home_imps :: ModSummary -> [Located ModuleName]+ms_home_imps = home_imps . ms_imps++-- The ModLocation contains both the original source filename and the+-- filename of the cleaned-up source file after all preprocessing has been+-- done.  The point is that the summariser will have to cpp/unlit/whatever+-- all files anyway, and there's no point in doing this twice -- just+-- park the result in a temp file, put the name of it in the location,+-- and let @compile@ read from that file on the way back up.++-- The ModLocation is stable over successive up-sweeps in GHCi, wheres+-- the ms_hs_date and imports can, of course, change++msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath+msHsFilePath  ms = expectJust "msHsFilePath" (ml_hs_file  (ms_location ms))+msHiFilePath  ms = ml_hi_file  (ms_location ms)+msObjFilePath ms = ml_obj_file (ms_location ms)++msDynObjFilePath :: ModSummary -> DynFlags -> FilePath+msDynObjFilePath ms dflags = dynamicOutputFile dflags (msObjFilePath ms)++-- | Did this 'ModSummary' originate from a hs-boot file?+isBootSummary :: ModSummary -> Bool+isBootSummary ms = ms_hsc_src ms == HsBootFile++instance Outputable ModSummary where+   ppr ms+      = sep [text "ModSummary {",+             nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),+                          text "ms_mod =" <+> ppr (ms_mod ms)+                                <> text (hscSourceString (ms_hsc_src ms)) <> comma,+                          text "ms_textual_imps =" <+> ppr (ms_textual_imps ms),+                          text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),+             char '}'+            ]++showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String+showModMsg dflags target recomp mod_summary = showSDoc dflags $+   if gopt Opt_HideSourcePaths dflags+      then text mod_str+      else hsep $+         [ text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' ')+         , char '('+         , text (op $ msHsFilePath mod_summary) <> char ','+         ] +++         if gopt Opt_BuildDynamicToo dflags+            then [ text obj_file <> char ','+                 , text dyn_file+                 , char ')'+                 ]+            else [ text obj_file, char ')' ]+  where+    op       = normalise+    mod      = moduleName (ms_mod mod_summary)+    mod_str  = showPpr dflags mod ++ hscSourceString (ms_hsc_src mod_summary)+    dyn_file = op $ msDynObjFilePath mod_summary dflags+    obj_file = case target of+                HscInterpreted | recomp -> "interpreted"+                HscNothing              -> "nothing"+                _                       -> (op $ msObjFilePath mod_summary)++{-+************************************************************************+*                                                                      *+\subsection{Recompilation}+*                                                                      *+************************************************************************+-}++-- | Indicates whether a given module's source has been modified since it+-- was last compiled.+data SourceModified+  = SourceModified+       -- ^ the source has been modified+  | SourceUnmodified+       -- ^ the source has not been modified.  Compilation may or may+       -- not be necessary, depending on whether any dependencies have+       -- changed since we last compiled.+  | SourceUnmodifiedAndStable+       -- ^ the source has not been modified, and furthermore all of+       -- its (transitive) dependencies are up to date; it definitely+       -- does not need to be recompiled.  This is important for two+       -- reasons: (a) we can omit the version check in checkOldIface,+       -- and (b) if the module used TH splices we don't need to force+       -- recompilation.++{-+************************************************************************+*                                                                      *+\subsection{Hpc Support}+*                                                                      *+************************************************************************+-}++-- | Information about a modules use of Haskell Program Coverage+data HpcInfo+  = HpcInfo+     { hpcInfoTickCount :: Int+     , hpcInfoHash      :: Int+     }+  | NoHpcInfo+     { hpcUsed          :: AnyHpcUsage  -- ^ Is hpc used anywhere on the module \*tree\*?+     }++-- | This is used to signal if one of my imports used HPC instrumentation+-- even if there is no module-local HPC usage+type AnyHpcUsage = Bool++emptyHpcInfo :: AnyHpcUsage -> HpcInfo+emptyHpcInfo = NoHpcInfo++-- | Find out if HPC is used by this module or any of the modules+-- it depends upon+isHpcUsed :: HpcInfo -> AnyHpcUsage+isHpcUsed (HpcInfo {})                   = True+isHpcUsed (NoHpcInfo { hpcUsed = used }) = used++{-+************************************************************************+*                                                                      *+\subsection{Safe Haskell Support}+*                                                                      *+************************************************************************++This stuff here is related to supporting the Safe Haskell extension,+primarily about storing under what trust type a module has been compiled.+-}++-- | Is an import a safe import?+type IsSafeImport = Bool++-- | Safe Haskell information for 'ModIface'+-- Simply a wrapper around SafeHaskellMode to sepperate iface and flags+newtype IfaceTrustInfo = TrustInfo SafeHaskellMode++getSafeMode :: IfaceTrustInfo -> SafeHaskellMode+getSafeMode (TrustInfo x) = x++setSafeMode :: SafeHaskellMode -> IfaceTrustInfo+setSafeMode = TrustInfo++noIfaceTrustInfo :: IfaceTrustInfo+noIfaceTrustInfo = setSafeMode Sf_None++trustInfoToNum :: IfaceTrustInfo -> Word8+trustInfoToNum it+  = case getSafeMode it of+            Sf_None         -> 0+            Sf_Unsafe       -> 1+            Sf_Trustworthy  -> 2+            Sf_Safe         -> 3+            Sf_SafeInferred -> 4+            Sf_Ignore       -> 0++numToTrustInfo :: Word8 -> IfaceTrustInfo+numToTrustInfo 0 = setSafeMode Sf_None+numToTrustInfo 1 = setSafeMode Sf_Unsafe+numToTrustInfo 2 = setSafeMode Sf_Trustworthy+numToTrustInfo 3 = setSafeMode Sf_Safe+numToTrustInfo 4 = setSafeMode Sf_SafeInferred+numToTrustInfo n = error $ "numToTrustInfo: bad input number! (" ++ show n ++ ")"++instance Outputable IfaceTrustInfo where+    ppr (TrustInfo Sf_None)          = text "none"+    ppr (TrustInfo Sf_Ignore)        = text "none"+    ppr (TrustInfo Sf_Unsafe)        = text "unsafe"+    ppr (TrustInfo Sf_Trustworthy)   = text "trustworthy"+    ppr (TrustInfo Sf_Safe)          = text "safe"+    ppr (TrustInfo Sf_SafeInferred)  = text "safe-inferred"++instance Binary IfaceTrustInfo where+    put_ bh iftrust = putByte bh $ trustInfoToNum iftrust+    get bh = getByte bh >>= (return . numToTrustInfo)++{-+************************************************************************+*                                                                      *+\subsection{Parser result}+*                                                                      *+************************************************************************+-}++data HsParsedModule = HsParsedModule {+    hpm_module    :: Located HsModule,+    hpm_src_files :: [FilePath],+       -- ^ extra source files (e.g. from #includes).  The lexer collects+       -- these from '# <file> <line>' pragmas, which the C preprocessor+       -- leaves behind.  These files and their timestamps are stored in+       -- the .hi file, so that we can force recompilation if any of+       -- them change (#3589)+    hpm_annotations :: ApiAnns+    -- See note [Api annotations] in ApiAnnotation.hs+  }++{-+************************************************************************+*                                                                      *+\subsection{Linkable stuff}+*                                                                      *+************************************************************************++This stuff is in here, rather than (say) in Linker.hs, because the Linker.hs+stuff is the *dynamic* linker, and isn't present in a stage-1 compiler+-}++isObjectLinkable :: Linkable -> Bool+isObjectLinkable l = not (null unlinked) && all isObject unlinked+  where unlinked = linkableUnlinked l+        -- A linkable with no Unlinked's is treated as a BCO.  We can+        -- generate a linkable with no Unlinked's as a result of+        -- compiling a module in HscNothing mode, and this choice+        -- happens to work well with checkStability in module GHC.++linkableObjs :: Linkable -> [FilePath]+linkableObjs l = [ f | DotO f <- linkableUnlinked l ]++-------------------------------------------++-- | Is this an actual file on disk we can link in somehow?+isObject :: Unlinked -> Bool+isObject (DotO _)   = True+isObject (DotA _)   = True+isObject (DotDLL _) = True+isObject _          = False++-- | Is this a bytecode linkable with no file on disk?+isInterpretable :: Unlinked -> Bool+isInterpretable = not . isObject++-- | Retrieve the filename of the linkable if possible. Panic if it is a byte-code object+nameOfObject :: Unlinked -> FilePath+nameOfObject (DotO fn)   = fn+nameOfObject (DotA fn)   = fn+nameOfObject (DotDLL fn) = fn+nameOfObject other       = pprPanic "nameOfObject" (ppr other)++-- | Retrieve the compiled byte-code if possible. Panic if it is a file-based linkable+byteCodeOfObject :: Unlinked -> CompiledByteCode+byteCodeOfObject (BCOs bc _) = bc+byteCodeOfObject other       = pprPanic "byteCodeOfObject" (ppr other)+++-------------------------------------------++-- | A list of conlikes which represents a complete pattern match.+-- These arise from @COMPLETE@ signatures.++-- See Note [Implementation of COMPLETE signatures]+data CompleteMatch = CompleteMatch {+                            completeMatchConLikes :: [Name]+                            -- ^ The ConLikes that form a covering family+                            -- (e.g. Nothing, Just)+                          , completeMatchTyCon :: Name+                            -- ^ The TyCon that they cover (e.g. Maybe)+                          }++instance Outputable CompleteMatch where+  ppr (CompleteMatch cl ty) = text "CompleteMatch:" <+> ppr cl+                                                    <+> dcolon <+> ppr ty++-- | A map keyed by the 'completeMatchTyCon'.++-- See Note [Implementation of COMPLETE signatures]+type CompleteMatchMap = UniqFM [CompleteMatch]++mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap+mkCompleteMatchMap = extendCompleteMatchMap emptyUFM++extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch]+                       -> CompleteMatchMap+extendCompleteMatchMap = foldl' insertMatch+  where+    insertMatch :: CompleteMatchMap -> CompleteMatch -> CompleteMatchMap+    insertMatch ufm c@(CompleteMatch _ t) = addToUFM_C (++) ufm t [c]++{-+Note [Implementation of COMPLETE signatures]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A COMPLETE signature represents a set of conlikes (i.e., constructors or+pattern synonyms) such that if they are all pattern-matched against in a+function, it gives rise to a total function. An example is:++  newtype Boolean = Boolean Int+  pattern F, T :: Boolean+  pattern F = Boolean 0+  pattern T = Boolean 1+  {-# COMPLETE F, T #-}++  -- This is a total function+  booleanToInt :: Boolean -> Int+  booleanToInt F = 0+  booleanToInt T = 1++COMPLETE sets are represented internally in GHC with the CompleteMatch data+type. For example, {-# COMPLETE F, T #-} would be represented as:++  CompleteMatch { complateMatchConLikes = [F, T]+                , completeMatchTyCon    = Boolean }++Note that GHC was able to infer the completeMatchTyCon (Boolean), but for the+cases in which it's ambiguous, you can also explicitly specify it in the source+language by writing this:++  {-# COMPLETE F, T :: Boolean #-}++For efficiency purposes, GHC collects all of the CompleteMatches that it knows+about into a CompleteMatchMap, which is a map that is keyed by the+completeMatchTyCon. In other words, you could have a multiple COMPLETE sets+for the same TyCon:++  {-# COMPLETE F, T1 :: Boolean #-}+  {-# COMPLETE F, T2 :: Boolean #-}++And looking up the values in the CompleteMatchMap associated with Boolean+would give you [CompleteMatch [F, T1] Boolean, CompleteMatch [F, T2] Boolean].+dsGetCompleteMatches in GHC.HsToCore.Quote accomplishes this lookup.++Also see Note [Typechecking Complete Matches] in TcBinds for a more detailed+explanation for how GHC ensures that all the conlikes in a COMPLETE set are+consistent.+-}++-- | Foreign language of the phase if the phase deals with a foreign code+phaseForeignLanguage :: Phase -> Maybe ForeignSrcLang+phaseForeignLanguage phase = case phase of+  Phase.Cc           -> Just LangC+  Phase.Ccxx         -> Just LangCxx+  Phase.Cobjc        -> Just LangObjc+  Phase.Cobjcxx      -> Just LangObjcxx+  Phase.HCc          -> Just LangC+  Phase.As _         -> Just LangAsm+  Phase.MergeForeign -> Just RawObject+  _                  -> Nothing++-------------------------------------------++-- Take care, this instance only forces to the degree necessary to+-- avoid major space leaks.+instance (NFData (IfaceBackendExts (phase :: ModIfacePhase)), NFData (IfaceDeclExts (phase :: ModIfacePhase))) => NFData (ModIface_ phase) where+  rnf (ModIface f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12+                f13 f14 f15 f16 f17 f18 f19 f20 f21 f22 f23) =+    rnf f1 `seq` rnf f2 `seq` f3 `seq` f4 `seq` f5 `seq` f6 `seq` rnf f7 `seq` f8 `seq`+    f9 `seq` rnf f10 `seq` rnf f11 `seq` f12 `seq` rnf f13 `seq` rnf f14 `seq` rnf f15 `seq`+    rnf f16 `seq` f17 `seq` rnf f18 `seq` rnf f19 `seq` f20 `seq` f21 `seq` f22 `seq` rnf f23

compiler/GHC/Hs.hs view

@@ -13,8 +13,8 @@ {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE FlexibleInstances #-} -- For deriving instance Data@@ -29,7 +29,6 @@         module GHC.Hs.Types,         module GHC.Hs.Utils,         module GHC.Hs.Doc,-        module GHC.Hs.PlaceHolder,         module GHC.Hs.Extension,         Fixity, @@ -44,7 +43,6 @@ import GHC.Hs.Expr import GHC.Hs.ImpExp import GHC.Hs.Lit-import GHC.Hs.PlaceHolder import GHC.Hs.Extension import GHC.Hs.Pat import GHC.Hs.Types

compiler/GHC/Hs/Binds.hs view

@@ -12,11 +12,14 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE LambdaCase #-}  module GHC.Hs.Binds where @@ -29,7 +32,7 @@  import GHC.Hs.Extension import GHC.Hs.Types-import CoreSyn+import GHC.Core import TcEvidence import Type import NameSet@@ -40,11 +43,10 @@ import Bag import FastString import BooleanFormula (LBooleanFormula)-import DynFlags  import Data.Data hiding ( Fixity ) import Data.List hiding ( foldr )-import Data.Ord+import Data.Function  {- ************************************************************************@@ -219,29 +221,29 @@     -- For details on above see note [Api annotations] in ApiAnnotation     FunBind { -        fun_ext :: XFunBind idL idR, -- ^ After the renamer, this contains-                                --  the locally-bound-                                -- free variables of this defn.-                                -- See Note [Bind free vars]+        fun_ext :: XFunBind idL idR, +          -- ^ After the renamer (but before the type-checker), this contains the+          -- locally-bound free variables of this defn. See Note [Bind free vars]+          --+          -- After the type-checker, this contains a coercion from the type of+          -- the MatchGroup to the type of the Id. Example:+          --+          -- @+          --      f :: Int -> forall a. a -> a+          --      f x y = y+          -- @+          --+          -- Then the MatchGroup will have type (Int -> a' -> a')+          -- (with a free type variable a').  The coercion will take+          -- a CoreExpr of this type and convert it to a CoreExpr of+          -- type         Int -> forall a'. a' -> a'+          -- Notice that the coercion captures the free a'.+         fun_id :: Located (IdP idL), -- Note [fun_id in Match] in GHC.Hs.Expr          fun_matches :: MatchGroup idR (LHsExpr idR),  -- ^ The payload -        fun_co_fn :: HsWrapper, -- ^ Coercion from the type of the MatchGroup to the type of-                                -- the Id.  Example:-                                ---                                -- @-                                --      f :: Int -> forall a. a -> a-                                --      f x y = y-                                -- @-                                ---                                -- Then the MatchGroup will have type (Int -> a' -> a')-                                -- (with a free type variable a').  The coercion will take-                                -- a CoreExpr of this type and convert it to a CoreExpr of-                                -- type         Int -> forall a'. a' -> a'-                                -- Notice that the coercion captures the free a'.-         fun_tick :: [Tickish Id] -- ^ Ticks to put on the rhs, if any     } @@ -320,8 +322,8 @@      } deriving Data  type instance XFunBind    (GhcPass pL) GhcPs = NoExtField-type instance XFunBind    (GhcPass pL) GhcRn = NameSet -- Free variables-type instance XFunBind    (GhcPass pL) GhcTc = NameSet -- Free variables+type instance XFunBind    (GhcPass pL) GhcRn = NameSet    -- Free variables+type instance XFunBind    (GhcPass pL) GhcTc = HsWrapper  -- See comments on FunBind.fun_ext  type instance XPatBind    GhcPs (GhcPass pR) = NoExtField type instance XPatBind    GhcRn (GhcPass pR) = NameSet -- Free variables@@ -572,7 +574,7 @@    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+These properties are exploited in GHC.HsToCore.Binds.dsAbsBinds to generate code without a let-binding.  Note [ABExport wrapper]@@ -665,7 +667,7 @@     decls = [(loc, ppr sig)  | L loc sig <- sigs] ++             [(loc, ppr bind) | L loc bind <- bagToList binds] -    sort_by_loc decls = sortBy (comparing fst) decls+    sort_by_loc decls = sortBy (SrcLoc.leftmost_smallest `on` fst) decls  pprDeclList :: [SDoc] -> SDoc   -- Braces with a space -- Print a bunch of declarations@@ -682,19 +684,6 @@ emptyLocalBinds :: HsLocalBindsLR (GhcPass a) (GhcPass b) emptyLocalBinds = EmptyLocalBinds noExtField --- AZ:These functions do not seem to be used at all?-isEmptyLocalBindsTc :: HsLocalBindsLR (GhcPass a) GhcTc -> Bool-isEmptyLocalBindsTc (HsValBinds _ ds)   = isEmptyValBinds ds-isEmptyLocalBindsTc (HsIPBinds _ ds)    = isEmptyIPBindsTc ds-isEmptyLocalBindsTc (EmptyLocalBinds _) = True-isEmptyLocalBindsTc (XHsLocalBindsLR _) = True--isEmptyLocalBindsPR :: HsLocalBindsLR (GhcPass a) (GhcPass b) -> Bool-isEmptyLocalBindsPR (HsValBinds _ ds)   = isEmptyValBinds ds-isEmptyLocalBindsPR (HsIPBinds _ ds)    = isEmptyIPBindsPR ds-isEmptyLocalBindsPR (EmptyLocalBinds _) = True-isEmptyLocalBindsPR (XHsLocalBindsLR _) = True- eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool eqEmptyLocalBinds (EmptyLocalBinds _) = True eqEmptyLocalBinds _                   = False@@ -728,7 +717,8 @@          => Outputable (HsBindLR (GhcPass pl) (GhcPass pr)) where     ppr mbind = ppr_monobind mbind -ppr_monobind :: (OutputableBndrId idL, OutputableBndrId idR)+ppr_monobind :: forall idL idR.+                (OutputableBndrId idL, OutputableBndrId idR)              => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc  ppr_monobind (PatBind { pat_lhs = pat, pat_rhs = grhss })@@ -736,39 +726,39 @@ ppr_monobind (VarBind { var_id = var, var_rhs = rhs })   = sep [pprBndr CasePatBind var, nest 2 $ equals <+> pprExpr (unLoc rhs)] ppr_monobind (FunBind { fun_id = fun,-                        fun_co_fn = wrap,                         fun_matches = matches,-                        fun_tick = ticks })+                        fun_tick = ticks,+                        fun_ext = wrap })   = pprTicks empty (if null ticks then empty                     else text "-- ticks = " <> ppr ticks)     $$  whenPprDebug (pprBndr LetBind (unLoc fun))     $$  pprFunBind  matches-    $$  whenPprDebug (ppr wrap)+    $$  whenPprDebug (pprIfTc @idR $ 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                        , abs_ev_binds = ev_binds })-  = sdocWithDynFlags $ \ dflags ->-    if gopt Opt_PrintTypecheckerElaboration dflags then-      -- Show extra information (bug number: #10662)-      hang (text "AbsBinds" <+> brackets (interpp'SP tyvars)-                                    <+> brackets (interpp'SP dictvars))-         2 $ braces $ vcat-      [ text "Exports:" <+>-          brackets (sep (punctuate comma (map ppr exports)))-      , text "Exported types:" <+>-          vcat [pprBndr LetBind (abe_poly ex) | ex <- exports]-      , text "Binds:" <+> pprLHsBinds val_binds-      , text "Evidence:" <+> ppr ev_binds ]-    else-      pprLHsBinds val_binds+  = sdocOption sdocPrintTypecheckerElaboration $ \case+      False -> pprLHsBinds val_binds+      True  -> -- Show extra information (bug number: #10662)+               hang (text "AbsBinds" <+> brackets (interpp'SP tyvars)+                                             <+> brackets (interpp'SP dictvars))+                  2 $ braces $ vcat+               [ text "Exports:" <+>+                   brackets (sep (punctuate comma (map ppr exports)))+               , text "Exported types:" <+>+                   vcat [pprBndr LetBind (abe_poly ex) | ex <- exports]+               , text "Binds:" <+> pprLHsBinds val_binds+               , pprIfTc @idR (text "Evidence:" <+> ppr ev_binds)+               ] ppr_monobind (XHsBindsLR x) = ppr x  instance OutputableBndrId p => Outputable (ABExport (GhcPass 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)]+           , pprIfTc @p $ nest 2 (text "wrap:" <+> ppr wrap) ]   ppr (XABExport x) = ppr x  instance (OutputableBndrId l, OutputableBndrId r,@@ -867,7 +857,7 @@ instance OutputableBndrId p        => Outputable (HsIPBinds (GhcPass p)) where   ppr (IPBinds ds bs) = pprDeeperList vcat (map ppr bs)-                        $$ whenPprDebug (ppr ds)+                        $$ whenPprDebug (pprIfTc @p $ ppr ds)   ppr (XHsIPBinds x) = ppr x  instance OutputableBndrId p => Outputable (IPBind (GhcPass p)) where

compiler/GHC/Hs/Decls.hs view

@@ -8,10 +8,12 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE ScopedTypeVariables #-}  {-# OPTIONS_GHC -Wno-incomplete-record-updates #-} @@ -83,7 +85,7 @@   RoleAnnotDecl(..), LRoleAnnotDecl, roleAnnotDeclName,   -- ** Injective type families   FamilyResultSig(..), LFamilyResultSig, InjectivityAnn(..), LInjectivityAnn,-  resultVariableName,+  resultVariableName, familyDeclLName, familyDeclName,    -- * Grouping   HsGroup(..),  emptyRdrGroup, emptyRnGroup, appendGroups, hsGroupInstDecls,@@ -208,10 +210,10 @@ One might wonder why we even bother separating top-level fixity signatures into two places at all. That is, why not just take the fixity signatures from `hs_tyclds` and put them into `hs_fixds` so that they are all in one-location? This ends up causing problems for `DsMeta.repTopDs`, which translates-each fixity signature in `hs_fixds` and `hs_tyclds` into a Template Haskell-`Dec`. If there are any duplicate signatures between the two fields, this will-result in an error (#17608).+location? This ends up causing problems for `GHC.HsToCore.Quote.repTopDs`,+which translates each fixity signature in `hs_fixds` and `hs_tyclds` into a+Template Haskell `Dec`. If there are any duplicate signatures between the two+fields, this will result in an error (#17608). -}  -- | Haskell Group@@ -710,11 +712,14 @@ tyFamInstDeclLName (TyFamInstDecl (XHsImplicitBndrs nec))   = noExtCon nec -tyClDeclLName :: TyClDecl pass -> Located (IdP pass)-tyClDeclLName (FamDecl { tcdFam = FamilyDecl { fdLName = ln } }) = ln-tyClDeclLName decl = tcdLName decl+tyClDeclLName :: TyClDecl (GhcPass p) -> Located (IdP (GhcPass p))+tyClDeclLName (FamDecl { tcdFam = fd })     = familyDeclLName fd+tyClDeclLName (SynDecl { tcdLName = ln })   = ln+tyClDeclLName (DataDecl { tcdLName = ln })  = ln+tyClDeclLName (ClassDecl { tcdLName = ln }) = ln+tyClDeclLName (XTyClDecl nec) = noExtCon nec -tcdName :: TyClDecl pass -> IdP pass+tcdName :: TyClDecl (GhcPass p) -> IdP (GhcPass p) tcdName = unLoc . tyClDeclLName  tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass@@ -1140,6 +1145,16 @@      -- said "type family Foo x where .."   | ClosedTypeFamily (Maybe [LTyFamInstEqn pass]) ++------------- Functions over FamilyDecls -----------++familyDeclLName :: FamilyDecl (GhcPass p) -> Located (IdP (GhcPass p))+familyDeclLName (FamilyDecl { fdLName = n }) = n+familyDeclLName (XFamilyDecl nec) = noExtCon nec++familyDeclName :: FamilyDecl (GhcPass p) -> IdP (GhcPass p)+familyDeclName = unLoc . familyDeclLName+ famResultKindSignature :: FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p)) famResultKindSignature (NoSig _) = Nothing famResultKindSignature (KindSig _ ki) = Just ki@@ -1155,6 +1170,8 @@ resultVariableName (TyVarSig _ sig) = Just $ hsLTyVarName sig resultVariableName _                = Nothing +------------- Pretty printing FamilyDecls -----------+ instance OutputableBndrId p        => Outputable (FamilyDecl (GhcPass p)) where   ppr = pprFamilyDecl TopLevel@@ -2007,7 +2024,10 @@     ppr StockStrategy    = text "stock"     ppr AnyclassStrategy = text "anyclass"     ppr NewtypeStrategy  = text "newtype"-    ppr (ViaStrategy ty) = text "via" <+> ppr ty+    ppr (ViaStrategy ty) = text "via" <+> case ghcPass @p of+                                            GhcPs -> ppr ty+                                            GhcRn -> ppr ty+                                            GhcTc -> ppr ty  -- | A short description of a @DerivStrategy'@. derivStrategyName :: DerivStrategy a -> SDoc

compiler/GHC/Hs/Expr.hs view

@@ -7,13 +7,16 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE TypeFamilyDependencies #-}  {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-} @@ -28,15 +31,13 @@ import GHC.Hs.Decls import GHC.Hs.Pat import GHC.Hs.Lit-import GHC.Hs.PlaceHolder ( NameOrRdrName ) import GHC.Hs.Extension import GHC.Hs.Types import GHC.Hs.Binds  -- others: import TcEvidence-import CoreSyn-import DynFlags ( gopt, GeneralFlag(Opt_PrintExplicitCoercions) )+import GHC.Core import Name import NameSet import BasicTypes@@ -53,6 +54,7 @@ -- libraries: import Data.Data hiding (Fixity(..)) import qualified Data.Data as Data (Fixity(..))+import qualified Data.Kind import Data.Maybe (isNothing)  import GHCi.RemoteTypes ( ForeignRef )@@ -89,14 +91,57 @@ type PostTcTable = [(Name, PostTcExpr)]  -------------------------+{- Note [NoSyntaxExpr]+~~~~~~~~~~~~~~~~~~~~~~+Syntax expressions can be missing (NoSyntaxExprRn or NoSyntaxExprTc)+for several reasons:++ 1. As described in Note [Rebindable if]++ 2. In order to suppress "not in scope: xyz" messages when a bit of+    rebindable syntax does not apply. For example, when using an irrefutable+    pattern in a BindStmt, we don't need a `fail` operator.++ 3. Rebindable syntax might just not make sense. For example, a BodyStmt+    contains the syntax for `guard`, but that's used only in monad comprehensions.+    If we had more of a whiz-bang type system, we might be able to rule this+    case out statically.+-}+ -- | Syntax Expression ----- SyntaxExpr is like 'PostTcExpr', but it's filled in a little earlier,--- by the renamer.  It's used for rebindable syntax.+-- SyntaxExpr is represents the function used in interpreting rebindable+-- syntax. In the parser, we have no information to supply; in the renamer,+-- we have the name of the function (but see+-- Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle)+-- and in the type-checker we have a more elaborate structure 'SyntaxExprTc'. --+-- In some contexts, rebindable syntax is not implemented, and so we have+-- constructors to represent that possibility in both the renamer and+-- typechecker instantiations.+-- -- E.g. @(>>=)@ is filled in before the renamer by the appropriate 'Name' for --      @(>>=)@, and then instantiated by the type checker with its type args --      etc+type family SyntaxExpr p++-- Defining SyntaxExpr in two stages allows for better type inference, because+-- we can declare SyntaxExprGhc to be injective (and closed). Without injectivity,+-- noSyntaxExpr would be ambiguous.+type instance SyntaxExpr (GhcPass p) = SyntaxExprGhc p++type family SyntaxExprGhc (p :: Pass) = (r :: Data.Kind.Type) | r -> p where+  SyntaxExprGhc 'Parsed      = NoExtField+  SyntaxExprGhc 'Renamed     = SyntaxExprRn+  SyntaxExprGhc 'Typechecked = SyntaxExprTc++-- | The function to use in rebindable syntax. See Note [NoSyntaxExpr].+data SyntaxExprRn = SyntaxExprRn (HsExpr GhcRn)+    -- Why is the payload not just a Name?+    -- See Note [Monad fail : Rebindable syntax, overloaded strings] in RnExpr+                  | NoSyntaxExprRn++-- | An expression with wrappers, used for rebindable syntax -- -- This should desugar to --@@ -104,52 +149,52 @@ -- >                         (syn_arg_wraps[1] arg1) ... -- -- where the actual arguments come from elsewhere in the AST.--- This could be defined using @GhcPass p@ and such, but it's--- harder to get it all to work out that way. ('noSyntaxExpr' is hard to--- write, for example.)-data SyntaxExpr p = SyntaxExpr { syn_expr      :: HsExpr p-                               , syn_arg_wraps :: [HsWrapper]-                               , syn_res_wrap  :: HsWrapper }+data SyntaxExprTc = SyntaxExprTc { syn_expr      :: HsExpr GhcTc+                                 , syn_arg_wraps :: [HsWrapper]+                                 , syn_res_wrap  :: HsWrapper }+                  | NoSyntaxExprTc  -- See Note [NoSyntaxExpr]  -- | This is used for rebindable-syntax pieces that are too polymorphic -- for tcSyntaxOp (trS_fmap and the mzip in ParStmt) noExpr :: HsExpr (GhcPass p) noExpr = HsLit noExtField (HsString (SourceText  "noExpr") (fsLit "noExpr")) -noSyntaxExpr :: SyntaxExpr (GhcPass p)-                              -- Before renaming, and sometimes after,-                              -- (if the syntax slot makes no sense)-noSyntaxExpr = SyntaxExpr { syn_expr      = HsLit noExtField-                                                  (HsString NoSourceText-                                                  (fsLit "noSyntaxExpr"))-                          , syn_arg_wraps = []-                          , syn_res_wrap  = WpHole }+noSyntaxExpr :: forall p. IsPass p => SyntaxExpr (GhcPass p)+                              -- Before renaming, and sometimes after+                              -- See Note [NoSyntaxExpr]+noSyntaxExpr = case ghcPass @p of+  GhcPs -> noExtField+  GhcRn -> NoSyntaxExprRn+  GhcTc -> NoSyntaxExprTc --- | Make a 'SyntaxExpr (HsExpr _)', missing its HsWrappers.-mkSyntaxExpr :: HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p)-mkSyntaxExpr expr = SyntaxExpr { syn_expr      = expr-                               , syn_arg_wraps = []-                               , syn_res_wrap  = WpHole }+-- | Make a 'SyntaxExpr GhcRn' from an expression+-- Used only in getMonadFailOp.+-- See Note [Monad fail : Rebindable syntax, overloaded strings] in RnExpr+mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn+mkSyntaxExpr = SyntaxExprRn --- | Make a 'SyntaxExpr Name' (the "rn" is because this is used in the--- renamer), missing its HsWrappers.-mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn-mkRnSyntaxExpr name = mkSyntaxExpr $ HsVar noExtField $ noLoc name-  -- don't care about filling in syn_arg_wraps because we're clearly-  -- not past the typechecker+-- | Make a 'SyntaxExpr' from a 'Name' (the "rn" is because this is used in the+-- renamer).+mkRnSyntaxExpr :: Name -> SyntaxExprRn+mkRnSyntaxExpr name = SyntaxExprRn $ HsVar noExtField $ noLoc name -instance OutputableBndrId p-       => Outputable (SyntaxExpr (GhcPass p)) where-  ppr (SyntaxExpr { syn_expr      = expr-                  , syn_arg_wraps = arg_wraps-                  , syn_res_wrap  = res_wrap })-    = sdocWithDynFlags $ \ dflags ->+instance Outputable SyntaxExprRn where+  ppr (SyntaxExprRn expr) = ppr expr+  ppr NoSyntaxExprRn      = text "<no syntax expr>"++instance Outputable SyntaxExprTc where+  ppr (SyntaxExprTc { syn_expr      = expr+                    , syn_arg_wraps = arg_wraps+                    , syn_res_wrap  = res_wrap })+    = sdocOption sdocPrintExplicitCoercions $ \print_co ->       getPprStyle $ \s ->-      if debugStyle s || gopt Opt_PrintExplicitCoercions dflags+      if debugStyle s || print_co       then ppr expr <> braces (pprWithCommas ppr arg_wraps)                     <> braces (ppr res_wrap)       else ppr expr +  ppr NoSyntaxExprTc = text "<no syntax expr>"+ -- | Command Syntax Table (for Arrow syntax) type CmdSyntaxTable p = [(Name, HsExpr p)] -- See Note [CmdSyntaxTable]@@ -330,10 +375,11 @@   --       'ApiAnnotation.AnnElse',    -- For details on above see note [Api annotations] in ApiAnnotation-  | HsIf        (XIf p)-                (Maybe (SyntaxExpr p)) -- cond function-                                        -- Nothing => use the built-in 'if'-                                        -- See Note [Rebindable if]+  | HsIf        (XIf p)        -- GhcPs: this is a Bool; False <=> do not use+                               --  rebindable syntax+                (SyntaxExpr p) -- cond function+                                 -- NoSyntaxExpr => use the built-in 'if'+                                 -- See Note [Rebindable if]                 (LHsExpr p)    --  predicate                 (LHsExpr p)    --  then part                 (LHsExpr p)    --  else part@@ -364,7 +410,7 @@    -- For details on above see note [Api annotations] in ApiAnnotation   | HsDo        (XDo p)                  -- Type of the whole expression-                (HsStmtContext Name)     -- The parameterisation is unimportant+                (HsStmtContext GhcRn)    -- The parameterisation is unimportant                                          -- because in this context we never use                                          -- the PatGuard or ParStmt variant                 (Located [ExprLStmt p]) -- "do":one or more stmts@@ -506,16 +552,6 @@   -- Expressions annotated with pragmas, written as {-# ... #-}   | HsPragE (XPragE p) (HsPragE p) (LHsExpr p) -  ----------------------------------------  -- 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 GHC.Hs.Utils.mkHsWrap.--  |  HsWrap     (XWrap p)-                HsWrapper    -- TRANSLATION-                (HsExpr p)-   | XExpr       (XXExpr p) -- Note [Trees that Grow] extension constructor  @@ -532,13 +568,23 @@                 -- _non-empty_ list of DataCons that have                 -- all the upd'd fields -      , rupd_in_tys  :: [Type] -- Argument types of *input* record type-      , rupd_out_tys :: [Type] --             and  *output* record type-                               -- The original type can be reconstructed-                               -- with conLikeResTy-      , rupd_wrap :: HsWrapper -- See note [Record Update HsWrapper]-      } deriving Data+      , rupd_in_tys  :: [Type]  -- Argument types of *input* record type+      , rupd_out_tys :: [Type]  --             and  *output* record type+                                -- The original type can be reconstructed+                                -- with conLikeResTy+      , rupd_wrap :: HsWrapper  -- See note [Record Update HsWrapper]+      } +-- | HsWrap appears only in typechecker output+-- Invariant: The contained Expr is *NOT* itself an HsWrap.+-- See Note [Detecting forced eta expansion] in GHC.HsToCore.Expr.+-- This invariant is maintained by GHC.Hs.Utils.mkHsWrap.+-- hs_syn is something like HsExpr or HsCmd+data HsWrap hs_syn = HsWrap HsWrapper      -- the wrapper+                            (hs_syn GhcTc) -- the thing that is wrapped++deriving instance (Data (hs_syn GhcTc), Typeable hs_syn) => Data (HsWrap hs_syn)+ -- ---------------------------------------------------------------------  type instance XVar           (GhcPass _) = NoExtField@@ -570,8 +616,11 @@ type instance XExplicitSum   GhcTc = [Type]  type instance XCase          (GhcPass _) = NoExtField-type instance XIf            (GhcPass _) = NoExtField +type instance XIf            GhcPs = Bool      -- True <=> might use rebindable syntax+type instance XIf            GhcRn = NoExtField+type instance XIf            GhcTc = NoExtField+ type instance XMultiIf       GhcPs = NoExtField type instance XMultiIf       GhcRn = NoExtField type instance XMultiIf       GhcTc = Type@@ -617,8 +666,9 @@  type instance XPragE         (GhcPass _) = NoExtField -type instance XWrap          (GhcPass _) = NoExtField-type instance XXExpr         (GhcPass _) = NoExtCon+type instance XXExpr         GhcPs       = NoExtCon+type instance XXExpr         GhcRn       = NoExtCon+type instance XXExpr         GhcTc       = HsWrap HsExpr  -- --------------------------------------------------------------------- @@ -732,8 +782,13 @@ whereas that would not be possible using a all to a polymorphic function (because you can't call a polymorphic function at an unboxed type). -So we use Nothing to mean "use the old built-in typing rule".+So we use NoSyntaxExpr to mean "use the old built-in typing rule". +A further complication is that, in the `deriving` code, we never want+to use rebindable syntax. So, even in GhcPs, we want to denote whether+to use rebindable syntax or not. This is done via the type instance+for XIf GhcPs.+ Note [Record Update HsWrapper] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ There is a wrapper in RecordUpd which is used for the *required*@@ -1002,16 +1057,12 @@  ppr_expr (ArithSeq _ _ info) = brackets (ppr info) -ppr_expr (HsWrap _ co_fn e)-  = pprHsWrapper co_fn (\parens -> if parens then pprExpr e-                                             else pprExpr e)- ppr_expr (HsSpliceE _ s)         = pprSplice s ppr_expr (HsBracket _ b)         = pprHsBracket b ppr_expr (HsRnBracketOut _ e []) = ppr e ppr_expr (HsRnBracketOut _ e ps) = ppr e $$ text "pending(rn)" <+> ppr ps ppr_expr (HsTcBracketOut _ _wrap e []) = ppr e-ppr_expr (HsTcBracketOut _ _wrap e ps) = ppr e $$ text "pending(tc)" <+> ppr ps+ppr_expr (HsTcBracketOut _ _wrap e ps) = ppr e $$ text "pending(tc)" <+> pprIfTc @p (ppr ps)  ppr_expr (HsProc _ pat (L _ (HsCmdTop _ cmd)))   = hsep [text "proc", ppr pat, ptext (sLit "->"), ppr cmd]@@ -1034,15 +1085,24 @@           ppr exp, text ")"]  ppr_expr (HsRecFld _ f) = ppr f-ppr_expr (XExpr x) = ppr x+ppr_expr (XExpr x) = case ghcPass @p of+  GhcPs -> ppr x+  GhcRn -> ppr x+  GhcTc -> case x of+    HsWrap co_fn e ->  pprHsWrapper co_fn (\parens -> if parens then pprExpr e+                                                      else pprExpr e) -ppr_infix_expr :: (OutputableBndrId p) => HsExpr (GhcPass p) -> Maybe SDoc++ppr_infix_expr :: forall p. (OutputableBndrId p) => HsExpr (GhcPass p) -> Maybe SDoc ppr_infix_expr (HsVar _ (L _ v))    = Just (pprInfixOcc v) ppr_infix_expr (HsConLikeOut _ c)   = Just (pprInfixOcc (conLikeName c)) ppr_infix_expr (HsRecFld _ f)       = Just (pprInfixOcc f) ppr_infix_expr (HsUnboundVar _ occ) = Just (pprInfixOcc occ)-ppr_infix_expr (HsWrap _ _ e)       = ppr_infix_expr e-ppr_infix_expr _                    = Nothing+ppr_infix_expr (XExpr x)+  | GhcTc <- ghcPass @p+  , HsWrap _ e <- x+  = ppr_infix_expr e+ppr_infix_expr _ = Nothing  ppr_apps :: (OutputableBndrId p)          => HsExpr (GhcPass p)@@ -1097,7 +1157,7 @@  -- | @'hsExprNeedsParens' p e@ returns 'True' if the expression @e@ needs -- parentheses under precedence @p@.-hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool+hsExprNeedsParens :: forall p. IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool hsExprNeedsParens p = go   where     go (HsVar{})                      = False@@ -1130,7 +1190,6 @@     go (ExprWithTySig{})              = p >= sigPrec     go (ArithSeq{})                   = False     go (HsPragE{})                    = p >= appPrec-    go (HsWrap _ _ e)                 = go e     go (HsSpliceE{})                  = False     go (HsBracket{})                  = False     go (HsRnBracketOut{})             = False@@ -1141,11 +1200,18 @@     go (HsBinTick _ _ _ (L _ e))      = go e     go (RecordCon{})                  = False     go (HsRecFld{})                   = False-    go (XExpr{})                      = True+    go (XExpr x)+      | GhcTc <- ghcPass @p+      , HsWrap _ e <- x+      = go e +      | otherwise+      = True++ -- | @'parenthesizeHsExpr' p e@ checks if @'hsExprNeedsParens' p e@ is true, -- and if so, surrounds @e@ with an 'HsPar'. Otherwise, it simply returns @e@.-parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)+parenthesizeHsExpr :: IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) parenthesizeHsExpr p le@(L loc e)   | hsExprNeedsParens p e = L loc (HsPar noExtField le)   | otherwise             = le@@ -1154,7 +1220,7 @@ stripParensHsExpr (L _ (HsPar _ e)) = stripParensHsExpr e stripParensHsExpr e = e -isAtomicHsExpr :: HsExpr id -> Bool+isAtomicHsExpr :: forall p. IsPass p => HsExpr (GhcPass p) -> Bool -- True of a single token isAtomicHsExpr (HsVar {})        = True isAtomicHsExpr (HsConLikeOut {}) = True@@ -1163,9 +1229,11 @@ isAtomicHsExpr (HsIPVar {})      = True isAtomicHsExpr (HsOverLabel {})  = True isAtomicHsExpr (HsUnboundVar {}) = True-isAtomicHsExpr (HsWrap _ _ e)    = isAtomicHsExpr e isAtomicHsExpr (HsPar _ e)       = isAtomicHsExpr (unLoc e) isAtomicHsExpr (HsRecFld{})      = True+isAtomicHsExpr (XExpr x)+  | GhcTc <- ghcPass @p+  , HsWrap _ e <- x              = isAtomicHsExpr e isAtomicHsExpr _                 = False  instance Outputable (HsPragE (GhcPass p)) where@@ -1258,10 +1326,10 @@     -- For details on above see note [Api annotations] in ApiAnnotation    | HsCmdIf     (XCmdIf id)-                (Maybe (SyntaxExpr id))         -- cond function-                (LHsExpr id)                    -- predicate-                (LHsCmd id)                     -- then part-                (LHsCmd id)                     -- else part+                (SyntaxExpr id)         -- cond function+                (LHsExpr id)            -- predicate+                (LHsCmd id)             -- then part+                (LHsCmd id)             -- else part     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnIf',     --       'ApiAnnotation.AnnSemi',     --       'ApiAnnotation.AnnThen','ApiAnnotation.AnnSemi',@@ -1287,11 +1355,6 @@      -- For details on above see note [Api annotations] in ApiAnnotation -  | HsCmdWrap   (XCmdWrap id)-                HsWrapper-                (HsCmd id)     -- If   cmd :: arg1 --> res-                               --      wrap :: arg1 "->" arg2-                               -- Then (HsCmdWrap wrap cmd) :: arg2 --> res   | XCmd        (XXCmd id)     -- Note [Trees that Grow] extension point  type instance XCmdArrApp  GhcPs = NoExtField@@ -1311,8 +1374,14 @@ type instance XCmdDo      GhcTc = Type  type instance XCmdWrap    (GhcPass _) = NoExtField-type instance XXCmd       (GhcPass _) = NoExtCon +type instance XXCmd       GhcPs = NoExtCon+type instance XXCmd       GhcRn = NoExtCon+type instance XXCmd       GhcTc = HsWrap HsCmd+    -- If   cmd :: arg1 --> res+    --      wrap :: arg1 "->" arg2+    -- Then (XCmd (HsWrap wrap cmd)) :: arg2 --> res+ -- | Haskell Array Application Type data HsArrAppType = HsHigherOrderApp | HsFirstOrderApp   deriving Data@@ -1403,8 +1472,6 @@  ppr_cmd (HsCmdDo _ (L _ stmts))  = pprDo ArrowExpr stmts -ppr_cmd (HsCmdWrap _ w cmd)-  = pprHsWrapper w (\_ -> parens (ppr_cmd cmd)) ppr_cmd (HsCmdArrApp _ arrow arg HsFirstOrderApp True)   = hsep [ppr_lexpr arrow, larrowt, ppr_lexpr arg] ppr_cmd (HsCmdArrApp _ arrow arg HsFirstOrderApp False)@@ -1429,7 +1496,11 @@ ppr_cmd (HsCmdArrForm _ op _ _ args)   = hang (text "(|" <+> ppr_lexpr op)          4 (sep (map (pprCmdArg.unLoc) args) <+> text "|)")-ppr_cmd (XCmd x) = ppr x+ppr_cmd (XCmd x) = case ghcPass @p of+  GhcPs -> ppr x+  GhcRn -> ppr x+  GhcTc -> case x of+    HsWrap w cmd -> pprHsWrapper w (\_ -> parens (ppr_cmd cmd))  pprCmdArg :: (OutputableBndrId p) => HsCmdTop (GhcPass p) -> SDoc pprCmdArg (HsCmdTop _ cmd)@@ -1502,7 +1573,7 @@ data Match p body   = Match {         m_ext :: XCMatch p body,-        m_ctxt :: HsMatchContext (NameOrRdrName (IdP p)),+        m_ctxt :: HsMatchContext (NoGhcTc p),           -- See note [m_ctxt in Match]         m_pats :: [LPat p], -- The patterns         m_grhss :: (GRHSs p body)@@ -1637,7 +1708,7 @@            => LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc pprPatBind pat (grhss)  = sep [ppr pat,-       nest 2 (pprGRHSs (PatBindRhs :: HsMatchContext (IdP (GhcPass p))) grhss)]+       nest 2 (pprGRHSs (PatBindRhs :: HsMatchContext (GhcPass p)) grhss)]  pprMatch :: (OutputableBndrId idR, Outputable body)          => Match (GhcPass idR) body -> SDoc@@ -1678,7 +1749,7 @@     (pat2:pats2) = pats1  pprGRHSs :: (OutputableBndrId idR, Outputable body)-         => HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc+         => HsMatchContext passL -> GRHSs (GhcPass idR) body -> SDoc pprGRHSs ctxt (GRHSs _ grhss (L _ binds))   = vcat (map (pprGRHS ctxt . unLoc) grhss)   -- Print the "where" even if the contents of the binds is empty. Only@@ -1688,7 +1759,7 @@ pprGRHSs _ (XGRHSs x) = ppr x  pprGRHS :: (OutputableBndrId idR, Outputable body)-        => HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc+        => HsMatchContext passL -> GRHS (GhcPass idR) body -> SDoc pprGRHS ctxt (GRHS _ [] body)  =  pp_rhs ctxt body @@ -1697,7 +1768,7 @@  pprGRHS _ (XGRHS x) = ppr x -pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc+pp_rhs :: Outputable body => HsMatchContext passL -> body -> SDoc pp_rhs ctxt rhs = matchSeparator ctxt <+> pprDeeper (ppr rhs)  {-@@ -1774,6 +1845,7 @@              (SyntaxExpr idR) -- The fail operator              -- The fail operator is noSyntaxExpr              -- if the pattern match can't fail+             -- See Note [NoSyntaxExpr] (2)    -- | 'ApplicativeStmt' represents an applicative expression built with   -- '<$>' and '<*>'.  It is generated by the renamer, and is desugared into the@@ -1947,6 +2019,7 @@                          -- match fails.                          -- The fail operator is noSyntaxExpr                          -- if the pattern match can't fail+                         -- See Note [NoSyntaxExpr] (2)     }   | ApplicativeArgMany     -- do { stmts; return vars }     { xarg_app_arg_many :: (XApplicativeArgMany idL)@@ -2308,15 +2381,17 @@         (XSpliced id)         ThModFinalizers     -- TH finalizers produced by the splice.         (HsSplicedThing id) -- The result of splicing-   | HsSplicedT-      DelayedSplice    | XSplice (XXSplice id)  -- Note [Trees that Grow] extension point +newtype HsSplicedT = HsSplicedT DelayedSplice deriving (Data)+ type instance XTypedSplice   (GhcPass _) = NoExtField type instance XUntypedSplice (GhcPass _) = NoExtField type instance XQuasiQuote    (GhcPass _) = NoExtField type instance XSpliced       (GhcPass _) = NoExtField-type instance XXSplice       (GhcPass _) = NoExtCon+type instance XXSplice       GhcPs       = NoExtCon+type instance XXSplice       GhcRn       = NoExtCon+type instance XXSplice       GhcTc       = HsSplicedT  -- | A splice can appear with various decorations wrapped around it. This data -- type captures explicitly how it was originally written, for use in the pretty@@ -2478,7 +2553,7 @@ ppr_splice_decl (HsUntypedSplice _ _ n e) = ppr_splice empty n e empty ppr_splice_decl e = pprSplice e -pprSplice :: (OutputableBndrId p) => HsSplice (GhcPass p) -> SDoc+pprSplice :: forall p. (OutputableBndrId p) => HsSplice (GhcPass p) -> SDoc pprSplice (HsTypedSplice _ DollarSplice n e)   = ppr_splice (text "$$") n e empty pprSplice (HsTypedSplice _ BareSplice _ _ )@@ -2489,8 +2564,11 @@   = ppr_splice empty  n e empty pprSplice (HsQuasiQuote _ n q _ s)      = ppr_quasi n q s pprSplice (HsSpliced _ _ thing)         = ppr thing-pprSplice (HsSplicedT {})               = text "Unevaluated typed splice"-pprSplice (XSplice x)                   = ppr x+pprSplice (XSplice x)                   = case ghcPass @p of+                                            GhcPs -> noExtCon x+                                            GhcRn -> noExtCon x+                                            GhcTc -> case x of+                                                       HsSplicedT _ -> text "Unevaluated typed splice"  ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc ppr_quasi n quoter quote = whenPprDebug (brackets (ppr n)) <>@@ -2601,8 +2679,8 @@ -- -- 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@+data HsMatchContext p+  = FunRhs { mc_fun        :: LIdP p    -- ^ function binder of @f@            , mc_fixity     :: LexicalFixity -- ^ fixing of @f@            , mc_strictness :: SrcStrictness -- ^ was @f@ banged?                                             -- See Note [FunBind vs PatBind]@@ -2618,20 +2696,20 @@                                 --    (Just b) | Just _ <- x = e                                 --             | otherwise   = e' -  | RecUpd                      -- ^Record update [used only in DsExpr to+  | RecUpd                      -- ^Record update [used only in GHC.HsToCore.Expr to                                 --    tell matchWrapper what sort of                                 --    runtime error message to generate] -  | StmtCtxt (HsStmtContext id) -- ^Pattern of a do-stmt, list comprehension,+  | StmtCtxt (HsStmtContext p)  -- ^Pattern of a do-stmt, list comprehension,                                 -- pattern guard, etc    | ThPatSplice            -- ^A Template Haskell pattern splice   | ThPatQuote             -- ^A Template Haskell pattern quotation [p| (a,b) |]   | PatSyn                 -- ^A pattern synonym declaration-  deriving Functor-deriving instance (Data id) => Data (HsMatchContext id)+deriving instance Data (HsMatchContext GhcPs)+deriving instance Data (HsMatchContext GhcRn) -instance OutputableBndr id => Outputable (HsMatchContext id) where+instance OutputableBndrId p => Outputable (HsMatchContext (GhcPass p)) where   ppr m@(FunRhs{})          = text "FunRhs" <+> ppr (mc_fun m) <+> ppr (mc_fixity m)   ppr LambdaExpr            = text "LambdaExpr"   ppr CaseAlt               = text "CaseAlt"@@ -2645,15 +2723,14 @@   ppr ThPatQuote            = text "ThPatQuote"   ppr PatSyn                = text "PatSyn" -isPatSynCtxt :: HsMatchContext id -> Bool+isPatSynCtxt :: HsMatchContext p -> Bool isPatSynCtxt ctxt =   case ctxt of     PatSyn -> True     _      -> False --- | Haskell Statement Context. It expects to be parameterised with one of--- 'RdrName', 'Name' or 'Id'-data HsStmtContext id+-- | Haskell Statement Context.+data HsStmtContext p   = ListComp   | MonadComp @@ -2662,11 +2739,11 @@   | ArrowExpr                        -- ^do-notation in an arrow-command context    | GhciStmtCtxt                     -- ^A command-line Stmt in GHCi pat <- rhs-  | PatGuard (HsMatchContext id)     -- ^Pattern guard for specified thing-  | ParStmtCtxt (HsStmtContext id)   -- ^A branch of a parallel stmt-  | TransStmtCtxt (HsStmtContext id) -- ^A branch of a transform stmt-  deriving Functor-deriving instance (Data id) => Data (HsStmtContext id)+  | PatGuard (HsMatchContext p)      -- ^Pattern guard for specified thing+  | ParStmtCtxt (HsStmtContext p)    -- ^A branch of a parallel stmt+  | TransStmtCtxt (HsStmtContext p)  -- ^A branch of a transform stmt+deriving instance Data (HsStmtContext GhcPs)+deriving instance Data (HsStmtContext GhcRn)  isComprehensionContext :: HsStmtContext id -> Bool -- Uses comprehension syntax [ e | quals ]@@ -2691,7 +2768,7 @@ isMonadCompContext MonadComp = True isMonadCompContext _         = False -matchSeparator :: HsMatchContext id -> SDoc+matchSeparator :: HsMatchContext p -> SDoc matchSeparator (FunRhs {})   = text "=" matchSeparator CaseAlt       = text "->" matchSeparator IfAlt         = text "->"@@ -2706,8 +2783,8 @@ matchSeparator ThPatQuote   = panic "unused" matchSeparator PatSyn       = panic "unused" -pprMatchContext :: (Outputable (NameOrRdrName id),Outputable id)-                => HsMatchContext id -> SDoc+pprMatchContext :: Outputable (IdP p)+                => HsMatchContext p -> SDoc pprMatchContext ctxt   | want_an ctxt = text "an" <+> pprMatchContextNoun ctxt   | otherwise    = text "a"  <+> pprMatchContextNoun ctxt@@ -2716,7 +2793,7 @@     want_an ProcExpr    = True     want_an _           = False -pprMatchContextNoun :: (Outputable (NameOrRdrName id),Outputable id)+pprMatchContextNoun :: Outputable (IdP id)                     => HsMatchContext id -> SDoc pprMatchContextNoun (FunRhs {mc_fun=L _ fun})                                     = text "equation for"@@ -2735,8 +2812,7 @@ pprMatchContextNoun PatSyn          = text "pattern synonym declaration"  ------------------pprAStmtContext, pprStmtContext :: (Outputable id,-                                    Outputable (NameOrRdrName id))+pprAStmtContext, pprStmtContext :: Outputable (IdP id)                                 => HsStmtContext id -> SDoc pprAStmtContext ctxt = article <+> pprStmtContext ctxt   where@@ -2769,13 +2845,13 @@   ifPprDebug (sep [text "transformed branch of", pprAStmtContext c])              (pprStmtContext c) -instance (Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p)))+instance OutputableBndrId p       => Outputable (HsStmtContext (GhcPass p)) where     ppr = pprStmtContext  -- Used to generate the string for a *runtime* error message-matchContextErrString :: Outputable id-                      => HsMatchContext id -> SDoc+matchContextErrString :: OutputableBndrId p+                      => HsMatchContext (GhcPass p) -> SDoc matchContextErrString (FunRhs{mc_fun=L _ fun})   = text "function" <+> ppr fun matchContextErrString CaseAlt                    = text "case" matchContextErrString IfAlt                      = text "multi-way if"@@ -2797,10 +2873,7 @@ matchContextErrString (StmtCtxt ListComp)          = text "list comprehension" matchContextErrString (StmtCtxt MonadComp)         = text "monad comprehension" -pprMatchInCtxt :: (OutputableBndrId idR,-                   -- TODO:AZ these constraints do not make sense-                 Outputable (NameOrRdrName (NameOrRdrName (IdP (GhcPass idR)))),-                 Outputable body)+pprMatchInCtxt :: (OutputableBndrId idR, Outputable body)                => Match (GhcPass idR) body -> SDoc pprMatchInCtxt match  = hang (text "In" <+> pprMatchContext (m_ctxt match)                                         <> colon)@@ -2809,7 +2882,7 @@ pprStmtInCtxt :: (OutputableBndrId idL,                   OutputableBndrId idR,                   Outputable body)-              => HsStmtContext (IdP (GhcPass idL))+              => HsStmtContext (GhcPass idL)               -> StmtLR (GhcPass idL) (GhcPass idR) body               -> SDoc pprStmtInCtxt ctxt (LastStmt _ e _ _)

compiler/GHC/Hs/Expr.hs-boot view

@@ -1,8 +1,8 @@ {-# LANGUAGE CPP, KindSignatures #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE RoleAnnotations #-} {-# LANGUAGE ExistentialQuantification #-}@@ -15,19 +15,19 @@ import {-# SOURCE #-} GHC.Hs.Pat  ( LPat ) import BasicTypes ( SpliceExplicitFlag(..)) import GHC.Hs.Extension ( OutputableBndrId, GhcPass )+import Data.Kind  ( Type )  type role HsExpr nominal type role HsCmd nominal type role MatchGroup nominal nominal type role GRHSs nominal nominal type role HsSplice nominal-type role SyntaxExpr nominal-data HsExpr (i :: *)-data HsCmd  (i :: *)-data HsSplice (i :: *)-data MatchGroup (a :: *) (body :: *)-data GRHSs (a :: *) (body :: *)-data SyntaxExpr (i :: *)+data HsExpr (i :: Type)+data HsCmd  (i :: Type)+data HsSplice (i :: Type)+data MatchGroup (a :: Type) (body :: Type)+data GRHSs (a :: Type) (body :: Type)+type family SyntaxExpr (i :: Type)  instance OutputableBndrId p => Outputable (HsExpr (GhcPass p)) instance OutputableBndrId p => Outputable (HsCmd (GhcPass p))

compiler/GHC/Hs/Extension.hs view

@@ -11,8 +11,14 @@ {-# LANGUAGE DataKinds #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE PatternSynonyms #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension+{-# LANGUAGE UndecidableSuperClasses #-}  -- for IsPass; see Note [NoGhcTc]+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE AllowAmbiguousTypes #-}      -- for pprIfTc, etc.  module GHC.Hs.Extension where @@ -22,7 +28,6 @@ import GhcPrelude  import Data.Data hiding ( Fixity )-import GHC.Hs.PlaceHolder import Name import RdrName import Var@@ -54,6 +59,74 @@ A further goal is to provide a means to harmonise the Template Haskell and haskell-src-exts ASTs as well. +Wrinkle: In order to print out the AST, we need to know it is Outputable.+We also sometimes need to branch on the particular pass that we're in+(e.g. to print out type information once we know it). In order to allow+both of these actions, we define OutputableBndrId, which gathers the necessary+OutputableBndr and IsPass constraints. The use of this constraint in instances+generally requires UndecidableInstances.++See also Note [IsPass] and Note [NoGhcTc].++Note [IsPass]+~~~~~~~~~~~~~+One challenge with the Trees That Grow approach+is that we sometimes have different information in different passes.+For example, we have++  type instance XViaStrategy GhcPs = LHsSigType GhcPs+  type instance XViaStrategy GhcRn = LHsSigType GhcRn+  type instance XViaStrategy GhcTc = Type++This means that printing a DerivStrategy (which contains an XViaStrategy)+might need to print a LHsSigType, or it might need to print a type. Yet we+want one Outputable instance for a DerivStrategy, instead of one per pass. We+could have a large constraint, including e.g. (Outputable (XViaStrategy p),+Outputable (XViaStrategy GhcTc)), and pass that around in every context where+we might output a DerivStrategy. But a simpler alternative is to pass a+witness to whichever pass we're in. When we pattern-match on that (GADT)+witness, we learn the pass identity and can then print away. To wit, we get+the definition of GhcPass and the functions isPass. These allow us to do away+with big constraints, passing around all manner of dictionaries we might or+might not use. It does mean that we have to manually use isPass when printing,+but these places are few.++See Note [NoGhcTc] about the superclass constraint to IsPass.++Note [NoGhcTc]+~~~~~~~~~~~~~~+An expression is parsed into HsExpr GhcPs, renamed into HsExpr GhcRn, and+then type-checked into HsExpr GhcTc. Not so for types! These get parsed+into HsType GhcPs, renamed into HsType GhcRn, and then type-checked into+Type. We never build an HsType GhcTc. Why do this? Because we need to be+able to compare type-checked types for equality, and we don't want to do+this with HsType.++This causes wrinkles within the AST, where we normally thing that the whole+AST travels through the GhcPs --> GhcRn --> GhcTc pipeline as one. So we+have the NoGhcTc type family, which just replaces GhcTc with GhcRn, so that+user-written types can be preserved (as HsType GhcRn) even in e.g. HsExpr GhcTc.++For example, this is used in ExprWithTySig:+    | ExprWithTySig+                (XExprWithTySig p)++                (LHsExpr p)+                (LHsSigWcType (NoGhcTc p))++If we have (e :: ty), we still want to be able to print that (with the :: ty)+after type-checking. So we retain the LHsSigWcType GhcRn, even in an+HsExpr GhcTc. That's what NoGhcTc does.++When we're printing the type annotation, we need to know+(Outputable (LHsSigWcType GhcRn)), even though we've assumed only that+(OutputableBndrId GhcTc). We thus must be able to prove OutputableBndrId (NoGhcTc p)+from OutputableBndrId p. The extra constraints in OutputableBndrId and+the superclass constraints of IsPass allow this. Note that the superclass+constraint of IsPass is *recursive*: it asserts that IsPass (NoGhcTcPass p) holds.+For this to make sense, we need -XUndecidableSuperClasses and the other constraint,+saying that NoGhcTcPass is idempotent.+ -}  -- | A placeholder type for TTG extension points that are not currently@@ -93,6 +166,12 @@ noExtCon :: NoExtCon -> a noExtCon x = case x of {} +-- | GHC's L prefixed variants wrap their vanilla variant in this type family,+-- to add 'SrcLoc' info via 'Located'. Other passes than 'GhcPass' not+-- interested in location information can define this instance as @f p@.+type family XRec p (f :: Type -> Type) = r | r -> p f+type instance XRec (GhcPass p) f = Located (f (GhcPass p))+ {- Note [NoExtCon and strict fields] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -130,11 +209,20 @@ code that consumes unused extension constructors. -} --- | 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)+-- | Used as a data type index for the hsSyn AST; also serves+-- as a singleton type for Pass+data GhcPass (c :: Pass) where+  GhcPs :: GhcPs+  GhcRn :: GhcRn+  GhcTc :: GhcTc +-- This really should never be entered, but the data-deriving machinery+-- needs the instance to exist.+instance Typeable p => Data (GhcPass p) where+  gunfold _ _ _ = panic "instance Data GhcPass"+  toConstr  _   = panic "instance Data GhcPass"+  dataTypeOf _  = panic "instance Data GhcPass"+ data Pass = Parsed | Renamed | Typechecked          deriving (Data) @@ -144,23 +232,43 @@ type GhcTc   = GhcPass 'Typechecked -- Old 'Id' type para, type GhcTcId = GhcTc                -- Old 'TcId' type param --- | GHC's L prefixed variants wrap their vanilla variant in this type family,--- to add 'SrcLoc' info via 'Located'. Other passes than 'GhcPass' not--- interested in location information can define this instance as @f p@.-type family XRec p (f :: * -> *) = r | r -> p f-type instance XRec (GhcPass p) f = Located (f (GhcPass p))+-- | Allows us to check what phase we're in at GHC's runtime.+-- For example, this class allows us to write+-- >  f :: forall p. IsPass p => HsExpr (GhcPass p) -> blah+-- >  f e = case ghcPass @p of+-- >          GhcPs ->    ... in this RHS we have HsExpr GhcPs...+-- >          GhcRn ->    ... in this RHS we have HsExpr GhcRn...+-- >          GhcTc ->    ... in this RHS we have HsExpr GhcTc...+-- which is very useful, for example, when pretty-printing.+-- See Note [IsPass].+class ( NoGhcTcPass (NoGhcTcPass p) ~ NoGhcTcPass p+      , IsPass (NoGhcTcPass p)+      ) => IsPass p where+  ghcPass :: GhcPass p +instance IsPass 'Parsed where+  ghcPass = GhcPs+instance IsPass 'Renamed where+  ghcPass = GhcRn+instance IsPass 'Typechecked where+  ghcPass = GhcTc+ -- | 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+type instance IdP (GhcPass p) = IdGhcP p +-- | Maps the "normal" id type for a given GHC pass+type family IdGhcP pass where+  IdGhcP 'Parsed      = RdrName+  IdGhcP 'Renamed     = Name+  IdGhcP 'Typechecked = Id+ type LIdP p = Located (IdP p)  -- | Marks that a field uses the GhcRn variant even when the pass -- parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because -- HsType GhcTc should never occur.+-- See Note [NoGhcTc] type family NoGhcTc (p :: Type) where     -- this way, GHC can figure out that the result is a GhcPass   NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)@@ -179,23 +287,10 @@ type family XEmptyLocalBinds x x' type family XXHsLocalBindsLR x x' -type ForallXHsLocalBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) =-       ( c (XHsValBinds      x x')-       , c (XHsIPBinds       x x')-       , c (XEmptyLocalBinds x x')-       , c (XXHsLocalBindsLR x x')-       )- -- ValBindsLR type families type family XValBinds    x x' type family XXValBindsLR x x' -type ForallXValBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) =-       ( c (XValBinds    x x')-       , c (XXValBindsLR x x')-       )-- -- HsBindsLR type families type family XFunBind    x x' type family XPatBind    x x'@@ -204,51 +299,22 @@ type family XPatSynBind x x' type family XXHsBindsLR x x' -type ForallXHsBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) =-       ( c (XFunBind    x x')-       , c (XPatBind    x x')-       , c (XVarBind    x x')-       , c (XAbsBinds   x x')-       , c (XPatSynBind x x')-       , c (XXHsBindsLR x x')-       )- -- ABExport type families type family XABE x type family XXABExport x -type ForallXABExport (c :: * -> Constraint) (x :: *) =-       ( c (XABE       x)-       , c (XXABExport x)-       )- -- PatSynBind type families type family XPSB x x' type family XXPatSynBind x x' -type ForallXPatSynBind  (c :: * -> Constraint) (x :: *) (x' :: *) =-       ( c (XPSB         x x')-       , c (XXPatSynBind x x')-       )- -- HsIPBinds type families type family XIPBinds    x type family XXHsIPBinds x -type ForallXHsIPBinds (c :: * -> Constraint) (x :: *) =-       ( c (XIPBinds    x)-       , c (XXHsIPBinds x)-       )- -- IPBind type families type family XCIPBind x type family XXIPBind x -type ForallXIPBind (c :: * -> Constraint) (x :: *) =-       ( c (XCIPBind x)-       , c (XXIPBind x)-       )- -- Sig type families type family XTypeSig          x type family XPatSynSig        x@@ -263,30 +329,10 @@ type family XCompleteMatchSig x type family XXSig             x -type ForallXSig (c :: * -> Constraint) (x :: *) =-       ( c (XTypeSig          x)-       , c (XPatSynSig        x)-       , c (XClassOpSig       x)-       , c (XIdSig            x)-       , c (XFixSig           x)-       , c (XInlineSig        x)-       , c (XSpecSig          x)-       , c (XSpecInstSig      x)-       , c (XMinimalSig       x)-       , c (XSCCFunSig        x)-       , c (XCompleteMatchSig x)-       , c (XXSig             x)-       )- -- FixitySig type families type family XFixitySig          x type family XXFixitySig         x -type ForallXFixitySig (c :: * -> Constraint) (x :: *) =-       ( c (XFixitySig         x)-       , c (XXFixitySig        x)-       )- -- StandaloneKindSig type families type family XStandaloneKindSig  x type family XXStandaloneKindSig x@@ -311,44 +357,16 @@ type family XRoleAnnotD  x type family XXHsDecl     x -type ForallXHsDecl (c :: * -> Constraint) (x :: *) =-       ( c (XTyClD       x)-       , c (XInstD       x)-       , c (XDerivD      x)-       , c (XValD        x)-       , c (XSigD        x)-       , c (XKindSigD    x)-       , c (XDefD        x)-       , c (XForD        x)-       , c (XWarningD    x)-       , c (XAnnD        x)-       , c (XRuleD       x)-       , c (XSpliceD     x)-       , c (XDocD        x)-       , c (XRoleAnnotD  x)-       , c (XXHsDecl    x)-       )- -- ------------------------------------- -- HsGroup type families type family XCHsGroup      x type family XXHsGroup      x -type ForallXHsGroup (c :: * -> Constraint) (x :: *) =-       ( c (XCHsGroup       x)-       , c (XXHsGroup       x)-       )- -- ------------------------------------- -- SpliceDecl type families type family XSpliceDecl       x type family XXSpliceDecl      x -type ForallXSpliceDecl (c :: * -> Constraint) (x :: *) =-       ( c (XSpliceDecl        x)-       , c (XXSpliceDecl       x)-       )- -- ------------------------------------- -- TyClDecl type families type family XFamDecl       x@@ -357,24 +375,11 @@ type family XClassDecl     x type family XXTyClDecl     x -type ForallXTyClDecl (c :: * -> Constraint) (x :: *) =-       ( c (XFamDecl       x)-       , c (XSynDecl       x)-       , c (XDataDecl      x)-       , c (XClassDecl     x)-       , c (XXTyClDecl     x)-       )- -- ------------------------------------- -- TyClGroup type families type family XCTyClGroup      x type family XXTyClGroup      x -type ForallXTyClGroup (c :: * -> Constraint) (x :: *) =-       ( c (XCTyClGroup       x)-       , c (XXTyClGroup       x)-       )- -- ------------------------------------- -- FamilyResultSig type families type family XNoSig            x@@ -382,75 +387,37 @@ type family XTyVarSig         x type family XXFamilyResultSig x -type ForallXFamilyResultSig (c :: * -> Constraint) (x :: *) =-       ( c (XNoSig            x)-       , c (XCKindSig         x)-       , c (XTyVarSig         x)-       , c (XXFamilyResultSig x)-       )- -- ------------------------------------- -- FamilyDecl type families type family XCFamilyDecl      x type family XXFamilyDecl      x -type ForallXFamilyDecl (c :: * -> Constraint) (x :: *) =-       ( c (XCFamilyDecl       x)-       , c (XXFamilyDecl       x)-       )- -- ------------------------------------- -- HsDataDefn type families type family XCHsDataDefn      x type family XXHsDataDefn      x -type ForallXHsDataDefn (c :: * -> Constraint) (x :: *) =-       ( c (XCHsDataDefn       x)-       , c (XXHsDataDefn       x)-       )- -- ------------------------------------- -- HsDerivingClause type families type family XCHsDerivingClause      x type family XXHsDerivingClause      x -type ForallXHsDerivingClause (c :: * -> Constraint) (x :: *) =-       ( c (XCHsDerivingClause       x)-       , c (XXHsDerivingClause       x)-       )- -- ------------------------------------- -- ConDecl type families type family XConDeclGADT   x type family XConDeclH98    x type family XXConDecl      x -type ForallXConDecl (c :: * -> Constraint) (x :: *) =-       ( c (XConDeclGADT    x)-       , c (XConDeclH98     x)-       , c (XXConDecl       x)-       )- -- ------------------------------------- -- FamEqn type families type family XCFamEqn      x r type family XXFamEqn      x r -type ForallXFamEqn (c :: * -> Constraint) (x :: *) (r :: *) =-       ( c (XCFamEqn       x r)-       , c (XXFamEqn       x r)-       )- -- ------------------------------------- -- ClsInstDecl type families type family XCClsInstDecl      x type family XXClsInstDecl      x -type ForallXClsInstDecl (c :: * -> Constraint) (x :: *) =-       ( c (XCClsInstDecl       x)-       , c (XXClsInstDecl       x)-       )- -- ------------------------------------- -- ClsInstDecl type families type family XClsInstD      x@@ -458,23 +425,11 @@ type family XTyFamInstD    x type family XXInstDecl     x -type ForallXInstDecl (c :: * -> Constraint) (x :: *) =-       ( c (XClsInstD       x)-       , c (XDataFamInstD   x)-       , c (XTyFamInstD     x)-       , c (XXInstDecl      x)-       )- -- ------------------------------------- -- DerivDecl type families type family XCDerivDecl      x type family XXDerivDecl      x -type ForallXDerivDecl (c :: * -> Constraint) (x :: *) =-       ( c (XCDerivDecl       x)-       , c (XXDerivDecl       x)-       )- -- ------------------------------------- -- DerivStrategy type family type family XViaStrategy x@@ -484,96 +439,48 @@ type family XCDefaultDecl      x type family XXDefaultDecl      x -type ForallXDefaultDecl (c :: * -> Constraint) (x :: *) =-       ( c (XCDefaultDecl       x)-       , c (XXDefaultDecl       x)-       )- -- ------------------------------------- -- DefaultDecl type families type family XForeignImport     x type family XForeignExport     x type family XXForeignDecl      x -type ForallXForeignDecl (c :: * -> Constraint) (x :: *) =-       ( c (XForeignImport      x)-       , c (XForeignExport      x)-       , c (XXForeignDecl       x)-       )- -- ------------------------------------- -- RuleDecls type families type family XCRuleDecls      x type family XXRuleDecls      x -type ForallXRuleDecls (c :: * -> Constraint) (x :: *) =-       ( c (XCRuleDecls       x)-       , c (XXRuleDecls       x)-       )-- -- ------------------------------------- -- RuleDecl type families type family XHsRule          x type family XXRuleDecl       x -type ForallXRuleDecl (c :: * -> Constraint) (x :: *) =-       ( c (XHsRule           x)-       , c (XXRuleDecl        x)-       )- -- ------------------------------------- -- RuleBndr type families type family XCRuleBndr      x type family XRuleBndrSig    x type family XXRuleBndr      x -type ForallXRuleBndr (c :: * -> Constraint) (x :: *) =-       ( c (XCRuleBndr       x)-       , c (XRuleBndrSig     x)-       , c (XXRuleBndr       x)-       )- -- ------------------------------------- -- WarnDecls type families type family XWarnings        x type family XXWarnDecls      x -type ForallXWarnDecls (c :: * -> Constraint) (x :: *) =-       ( c (XWarnings        x)-       , c (XXWarnDecls      x)-       )- -- ------------------------------------- -- AnnDecl type families type family XWarning        x type family XXWarnDecl      x -type ForallXWarnDecl (c :: * -> Constraint) (x :: *) =-       ( c (XWarning        x)-       , c (XXWarnDecl      x)-       )- -- ------------------------------------- -- AnnDecl type families type family XHsAnnotation  x type family XXAnnDecl      x -type ForallXAnnDecl (c :: * -> Constraint) (x :: *) =-       ( c (XHsAnnotation  x)-       , c (XXAnnDecl      x)-       )- -- ------------------------------------- -- RoleAnnotDecl type families type family XCRoleAnnotDecl  x type family XXRoleAnnotDecl  x -type ForallXRoleAnnotDecl (c :: * -> Constraint) (x :: *) =-       ( c (XCRoleAnnotDecl  x)-       , c (XXRoleAnnotDecl  x)-       )- -- ===================================================================== -- Type families for the HsExpr extension points @@ -615,82 +522,24 @@ type family XTick           x type family XBinTick        x type family XPragE          x-type family XWrap           x type family XXExpr          x  type family XSCC            x type family XCoreAnn        x type family XTickPragma     x type family XXPragE         x--type ForallXExpr (c :: * -> Constraint) (x :: *) =-       ( c (XVar            x)-       , c (XUnboundVar     x)-       , c (XConLikeOut     x)-       , c (XRecFld         x)-       , c (XOverLabel      x)-       , c (XIPVar          x)-       , c (XOverLitE       x)-       , c (XLitE           x)-       , c (XLam            x)-       , c (XLamCase        x)-       , c (XApp            x)-       , c (XAppTypeE       x)-       , c (XOpApp          x)-       , c (XNegApp         x)-       , c (XPar            x)-       , c (XSectionL       x)-       , c (XSectionR       x)-       , c (XExplicitTuple  x)-       , c (XExplicitSum    x)-       , c (XCase           x)-       , c (XIf             x)-       , c (XMultiIf        x)-       , c (XLet            x)-       , c (XDo             x)-       , c (XExplicitList   x)-       , c (XRecordCon      x)-       , c (XRecordUpd      x)-       , c (XExprWithTySig  x)-       , c (XArithSeq       x)-       , c (XSCC            x)-       , c (XCoreAnn        x)-       , c (XBracket        x)-       , c (XRnBracketOut   x)-       , c (XTcBracketOut   x)-       , c (XSpliceE        x)-       , c (XProc           x)-       , c (XStatic         x)-       , c (XTick           x)-       , c (XBinTick        x)-       , c (XTickPragma     x)-       , c (XWrap           x)-       , c (XXExpr          x)-       ) -- ---------------------------------------------------------------------  type family XUnambiguous        x type family XAmbiguous          x type family XXAmbiguousFieldOcc x -type ForallXAmbiguousFieldOcc (c :: * -> Constraint) (x :: *) =-       ( c (XUnambiguous        x)-       , c (XAmbiguous          x)-       , c (XXAmbiguousFieldOcc x)-       )- -- ----------------------------------------------------------------------  type family XPresent  x type family XMissing  x type family XXTupArg  x -type ForallXTupArg (c :: * -> Constraint) (x :: *) =-       ( c (XPresent x)-       , c (XMissing x)-       , c (XXTupArg x)-       )- -- ---------------------------------------------------------------------  type family XTypedSplice   x@@ -699,14 +548,6 @@ type family XSpliced       x type family XXSplice       x -type ForallXSplice (c :: * -> Constraint) (x :: *) =-       ( c (XTypedSplice   x)-       , c (XUntypedSplice x)-       , c (XQuasiQuote    x)-       , c (XSpliced       x)-       , c (XXSplice       x)-       )- -- ---------------------------------------------------------------------  type family XExpBr      x@@ -718,67 +559,31 @@ type family XTExpBr     x type family XXBracket   x -type ForallXBracket (c :: * -> Constraint) (x :: *) =-       ( c (XExpBr      x)-       , c (XPatBr      x)-       , c (XDecBrL     x)-       , c (XDecBrG     x)-       , c (XTypBr      x)-       , c (XVarBr      x)-       , c (XTExpBr     x)-       , c (XXBracket   x)-       )- -- ---------------------------------------------------------------------  type family XCmdTop  x type family XXCmdTop x -type ForallXCmdTop (c :: * -> Constraint) (x :: *) =-       ( c (XCmdTop  x)-       , c (XXCmdTop x)-       )- -- -------------------------------------  type family XMG           x b type family XXMatchGroup  x b -type ForallXMatchGroup (c :: * -> Constraint) (x :: *) (b :: *) =-       ( c (XMG          x b)-       , c (XXMatchGroup x b)-       )- -- -------------------------------------  type family XCMatch  x b type family XXMatch  x b -type ForallXMatch (c :: * -> Constraint) (x :: *) (b :: *) =-       ( c (XCMatch  x b)-       , c (XXMatch  x b)-       )- -- -------------------------------------  type family XCGRHSs  x b type family XXGRHSs  x b -type ForallXGRHSs (c :: * -> Constraint) (x :: *) (b :: *) =-       ( c (XCGRHSs  x b)-       , c (XXGRHSs  x b)-       )- -- -------------------------------------  type family XCGRHS  x b type family XXGRHS  x b -type ForallXGRHS (c :: * -> Constraint) (x :: *) (b :: *) =-       ( c (XCGRHS  x b)-       , c (XXGRHS  x b)-       )- -- -------------------------------------  type family XLastStmt        x x' b@@ -791,18 +596,6 @@ type family XRecStmt         x x' b type family XXStmtLR         x x' b -type ForallXStmtLR (c :: * -> Constraint) (x :: *)  (x' :: *) (b :: *) =-       ( c (XLastStmt         x x' b)-       , c (XBindStmt         x x' b)-       , c (XApplicativeStmt  x x' b)-       , c (XBodyStmt         x x' b)-       , c (XLetStmt          x x' b)-       , c (XParStmt          x x' b)-       , c (XTransStmt        x x' b)-       , c (XRecStmt          x x' b)-       , c (XXStmtLR          x x' b)-       )- -- ---------------------------------------------------------------------  type family XCmdArrApp  x@@ -817,42 +610,17 @@ type family XCmdWrap    x type family XXCmd       x -type ForallXCmd (c :: * -> Constraint) (x :: *) =-       ( c (XCmdArrApp  x)-       , c (XCmdArrForm x)-       , c (XCmdApp     x)-       , c (XCmdLam     x)-       , c (XCmdPar     x)-       , c (XCmdCase    x)-       , c (XCmdIf      x)-       , c (XCmdLet     x)-       , c (XCmdDo      x)-       , c (XCmdWrap    x)-       , c (XXCmd       x)-       )- -- ---------------------------------------------------------------------  type family XParStmtBlock  x x' type family XXParStmtBlock x x' -type ForallXParStmtBlock (c :: * -> Constraint) (x :: *) (x' :: *) =-       ( c (XParStmtBlock  x x')-       , c (XXParStmtBlock x x')-       )- -- ---------------------------------------------------------------------  type family XApplicativeArgOne   x type family XApplicativeArgMany  x type family XXApplicativeArg     x -type ForallXApplicativeArg (c :: * -> Constraint) (x :: *) =-       ( c (XApplicativeArgOne   x)-       , c (XApplicativeArgMany  x)-       , c (XXApplicativeArg     x)-       )- -- ===================================================================== -- Type families for the HsImpExp extension points @@ -878,33 +646,9 @@ type family XHsDoublePrim x type family XXLit x --- | Helper to apply a constraint to all extension points. It has one--- entry per extension point type family.-type ForallXHsLit (c :: * -> Constraint) (x :: *) =-  ( c (XHsChar       x)-  , c (XHsCharPrim   x)-  , c (XHsDoublePrim x)-  , c (XHsFloatPrim  x)-  , c (XHsInt        x)-  , c (XHsInt64Prim  x)-  , c (XHsIntPrim    x)-  , c (XHsInteger    x)-  , c (XHsRat        x)-  , c (XHsString     x)-  , c (XHsStringPrim x)-  , c (XHsWord64Prim x)-  , c (XHsWordPrim   x)-  , c (XXLit         x)-  )- type family XOverLit  x type family XXOverLit x -type ForallXOverLit (c :: * -> Constraint) (x :: *) =-       ( c (XOverLit  x)-       , c (XXOverLit x)-       )- -- ===================================================================== -- Type families for the HsPat extension points @@ -927,58 +671,22 @@ type family XCoPat     x type family XXPat      x --type ForallXPat (c :: * -> Constraint) (x :: *) =-       ( c (XWildPat   x)-       , c (XVarPat    x)-       , c (XLazyPat   x)-       , c (XAsPat     x)-       , c (XParPat    x)-       , c (XBangPat   x)-       , c (XListPat   x)-       , c (XTuplePat  x)-       , c (XSumPat    x)-       , c (XViewPat   x)-       , c (XSplicePat x)-       , c (XLitPat    x)-       , c (XNPat      x)-       , c (XNPlusKPat x)-       , c (XSigPat    x)-       , c (XCoPat     x)-       , c (XXPat      x)-       )- -- ===================================================================== -- Type families for the HsTypes type families  type family XHsQTvs       x type family XXLHsQTyVars  x -type ForallXLHsQTyVars (c :: * -> Constraint) (x :: *) =-       ( c (XHsQTvs       x)-       , c (XXLHsQTyVars  x)-       )- -- -------------------------------------  type family XHsIB              x b type family XXHsImplicitBndrs  x b -type ForallXHsImplicitBndrs (c :: * -> Constraint) (x :: *) (b :: *) =-       ( c (XHsIB              x b)-       , c (XXHsImplicitBndrs  x b)-       )- -- -------------------------------------  type family XHsWC              x b type family XXHsWildCardBndrs  x b -type ForallXHsWildCardBndrs(c :: * -> Constraint) (x :: *) (b :: *) =-       ( c (XHsWC              x b)-       , c (XXHsWildCardBndrs  x b)-       )- -- -------------------------------------  type family XForAllTy        x@@ -1005,78 +713,28 @@ type family XWildCardTy      x type family XXType           x --- | Helper to apply a constraint to all extension points. It has one--- entry per extension point type family.-type ForallXType (c :: * -> Constraint) (x :: *) =-       ( c (XForAllTy        x)-       , c (XQualTy          x)-       , c (XTyVar           x)-       , c (XAppTy           x)-       , c (XAppKindTy       x)-       , c (XFunTy           x)-       , c (XListTy          x)-       , c (XTupleTy         x)-       , c (XSumTy           x)-       , c (XOpTy            x)-       , c (XParTy           x)-       , c (XIParamTy        x)-       , c (XStarTy          x)-       , c (XKindSig         x)-       , c (XSpliceTy        x)-       , c (XDocTy           x)-       , c (XBangTy          x)-       , c (XRecTy           x)-       , c (XExplicitListTy  x)-       , c (XExplicitTupleTy x)-       , c (XTyLit           x)-       , c (XWildCardTy      x)-       , c (XXType           x)-       )- -- ---------------------------------------------------------------------  type family XUserTyVar   x type family XKindedTyVar x type family XXTyVarBndr  x -type ForallXTyVarBndr (c :: * -> Constraint) (x :: *) =-       ( c (XUserTyVar      x)-       , c (XKindedTyVar    x)-       , c (XXTyVarBndr     x)-       )- -- ---------------------------------------------------------------------  type family XConDeclField  x type family XXConDeclField x -type ForallXConDeclField (c :: * -> Constraint) (x :: *) =-       ( c (XConDeclField  x)-       , c (XXConDeclField x)-       )- -- ---------------------------------------------------------------------  type family XCFieldOcc x type family XXFieldOcc x -type ForallXFieldOcc (c :: * -> Constraint) (x :: *) =-       ( c (XCFieldOcc x)-       , c (XXFieldOcc x)-       )-- -- ===================================================================== -- Type families for the HsImpExp type families  type family XCImportDecl       x type family XXImportDecl       x -type ForallXImportDecl (c :: * -> Constraint) (x :: *) =-       ( c (XCImportDecl x)-       , c (XXImportDecl x)-       )- -- -------------------------------------  type family XIEVar             x@@ -1089,18 +747,6 @@ type family XIEDocNamed        x type family XXIE               x -type ForallXIE (c :: * -> Constraint) (x :: *) =-       ( c (XIEVar x)-       , c (XIEThingAbs        x)-       , c (XIEThingAll        x)-       , c (XIEThingWith       x)-       , c (XIEModuleContents  x)-       , c (XIEGroup           x)-       , c (XIEDoc             x)-       , c (XIEDocNamed        x)-       , c (XXIE               x)-       )- -- -------------------------------------  @@ -1108,77 +754,23 @@ -- End of Type family definitions -- ===================================================================== --- ------------------------------------------------------------------------- | 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,-   XXLit a ~ XXLit b)---- -------------------------------------------------------------------------- Note [OutputableX]--- ~~~~~~~~~~~~~~~~~~------ is required because the type family resolution--- process cannot determine that all cases are handled for a `GhcPass p`--- case where the cases are listed separately.------ So------   type instance XXHsIPBinds    (GhcPass p) = NoExtCon------ will correctly deduce Outputable for (GhcPass p), but------   type instance XIPBinds       GhcPs = NoExt---   type instance XIPBinds       GhcRn = NoExt---   type instance XIPBinds       GhcTc = TcEvBinds------ will not.----- | Provide a summary constraint that gives all am Outputable constraint to--- extension points needing one-type OutputableX p = -- See Note [OutputableX]-  ( Outputable (XIPBinds    p)-  , Outputable (XViaStrategy p)-  , Outputable (XViaStrategy GhcRn)-  )--- TODO: Should OutputableX be included in OutputableBndrId?---- ----------------------------------------------------------------------- -- |Constraint type to bundle up the requirement for 'OutputableBndr' on both--- the @p@ and the 'NameOrRdrName' type for it+-- the @id@ and the 'NoGhcTc' of it. See Note [NoGhcTc]. type OutputableBndrId pass =-  ( OutputableBndr (NameOrRdrName (IdP (GhcPass pass)))-  , OutputableBndr (IdP (GhcPass pass))-  , OutputableBndr (NameOrRdrName (IdP (NoGhcTc (GhcPass pass))))-  , OutputableBndr (IdP (NoGhcTc (GhcPass pass)))-  , NoGhcTc (GhcPass pass) ~ NoGhcTc (NoGhcTc (GhcPass pass))-  , OutputableX (GhcPass pass)-  , OutputableX (NoGhcTc (GhcPass pass))+  ( OutputableBndr (IdGhcP pass)+  , OutputableBndr (IdGhcP (NoGhcTcPass pass))+  , IsPass pass   )++-- useful helper functions:+pprIfPs :: forall p. IsPass p => (p ~ 'Parsed => SDoc) -> SDoc+pprIfPs pp = case ghcPass @p of GhcPs -> pp+                                _     -> empty++pprIfRn :: forall p. IsPass p => (p ~ 'Renamed => SDoc) -> SDoc+pprIfRn pp = case ghcPass @p of GhcRn -> pp+                                _     -> empty++pprIfTc :: forall p. IsPass p => (p ~ 'Typechecked => SDoc) -> SDoc+pprIfTc pp = case ghcPass @p of GhcTc -> pp+                                _     -> empty

compiler/GHC/Hs/ImpExp.hs view

@@ -11,8 +11,8 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension  module GHC.Hs.ImpExp where

compiler/GHC/Hs/Instances.hs view

@@ -242,11 +242,6 @@ -- --------------------------------------------------------------------- -- Data derivations from GHC.Hs.Expr ----------------------------------- --- deriving instance (DataIdLR p p) => Data (SyntaxExpr p)-deriving instance Data (SyntaxExpr GhcPs)-deriving instance Data (SyntaxExpr GhcRn)-deriving instance Data (SyntaxExpr GhcTc)- -- deriving instance (DataIdLR p p) => Data (HsPragE p) deriving instance Data (HsPragE GhcPs) deriving instance Data (HsPragE GhcRn)@@ -331,10 +326,13 @@ deriving instance Data (ArithSeqInfo GhcRn) deriving instance Data (ArithSeqInfo GhcTc) -deriving instance                   Data RecordConTc-deriving instance                   Data CmdTopTc-deriving instance                   Data PendingRnSplice-deriving instance                   Data PendingTcSplice+deriving instance Data RecordConTc+deriving instance Data RecordUpdTc+deriving instance Data CmdTopTc+deriving instance Data PendingRnSplice+deriving instance Data PendingTcSplice+deriving instance Data SyntaxExprRn+deriving instance Data SyntaxExprTc  -- --------------------------------------------------------------------- -- Data derivations from GHC.Hs.Lit ------------------------------------

compiler/GHC/Hs/Lit.hs view

@@ -10,8 +10,8 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TypeFamilies #-} @@ -151,23 +151,22 @@ overLitType (OverLit (OverLitTc _ ty) _ _) = ty overLitType (XOverLit nec) = noExtCon nec --- | 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)-convertLit (XLit a)           = (XLit (convert a))+-- | Convert a literal from one index type to another+convertLit :: HsLit (GhcPass p1) -> HsLit (GhcPass p2)+convertLit (HsChar a x)       = HsChar a x+convertLit (HsCharPrim a x)   = HsCharPrim a x+convertLit (HsString a x)     = HsString a x+convertLit (HsStringPrim a x) = HsStringPrim a x+convertLit (HsInt a x)        = HsInt a x+convertLit (HsIntPrim a x)    = HsIntPrim a x+convertLit (HsWordPrim a x)   = HsWordPrim a x+convertLit (HsInt64Prim a x)  = HsInt64Prim a x+convertLit (HsWord64Prim a x) = HsWord64Prim a x+convertLit (HsInteger a x b)  = HsInteger a x b+convertLit (HsRat a x b)      = HsRat a x b+convertLit (HsFloatPrim a x)  = HsFloatPrim a x+convertLit (HsDoublePrim a x) = HsDoublePrim a x+convertLit (XLit a)           = XLit a  {- Note [ol_rebindable]@@ -200,7 +199,7 @@ -}  -- Comparison operations are needed when grouping literals--- for compiling pattern-matching (module MatchLit)+-- for compiling pattern-matching (module GHC.HsToCore.Match.Literal) instance (Eq (XXOverLit p)) => Eq (HsOverLit p) where   (OverLit _ val1 _) == (OverLit _ val2 _) = val1 == val2   (XOverLit  val1)   == (XOverLit  val2)   = val1 == val2

compiler/GHC/Hs/Pat.hs view

@@ -11,12 +11,15 @@ {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE ViewPatterns      #-} {-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE LambdaCase #-}  module GHC.Hs.Pat (         Pat(..), InPat, OutPat, LPat,@@ -31,6 +34,7 @@          mkPrefixConPat, mkCharLitPat, mkNilPat, +        isSimplePat,         looksLazyPatBind,         isBangedLPat,         patNeedsParens, parenthesizePat,@@ -53,7 +57,7 @@ import TcEvidence import BasicTypes -- others:-import PprCore          ( {- instance OutputableBndr TyVar -} )+import GHC.Core.Ppr ( {- instance OutputableBndr TyVar -} ) import TysWiredIn import Var import RdrName ( RdrName )@@ -64,7 +68,6 @@ import Type import SrcLoc import Bag -- collect ev vars from pats-import DynFlags( gopt, GeneralFlag(..) ) import Maybes -- libraries: import Data.Data hiding (TyCon,Fixity)@@ -155,9 +158,7 @@     --            'ApiAnnotation.AnnOpen' @'('@ or @'(#'@,     --            'ApiAnnotation.AnnClose' @')'@ or  @'#)'@ -  | SumPat      (XSumPat p)        -- GHC.Hs.PlaceHolder before typechecker, filled in-                                   -- afterwards with the types of the-                                   -- alternative+  | SumPat      (XSumPat p)        -- after typechecker, types of the alternative                 (LPat p)           -- Sum sub-pattern                 ConTag             -- Alternative (one-based)                 Arity              -- Arity (INVARIANT: ≥ 2)@@ -245,7 +246,7 @@                      -- a new hs-boot file. Not worth it.                      (SyntaxExpr p)   -- (>=) function, of type t1->t2->Bool-                    (SyntaxExpr p)   -- Name of '-' (see GHC.Rename.Env.lookupSyntaxName)+                    (SyntaxExpr p)   -- Name of '-' (see GHC.Rename.Env.lookupSyntax)   -- ^ n+k pattern          ------------ Pattern type signatures ---------------@@ -274,6 +275,7 @@   | XPat       (XXPat p) + -- ---------------------------------------------------------------------  data ListPatTc@@ -423,7 +425,7 @@ -- -- The renamer produces an Unambiguous result if it can, rather than -- just doing the lookup in the typechecker, so that completely--- unambiguous updates can be represented by 'DsMeta.repUpdFields'.+-- unambiguous updates can be represented by 'GHC.HsToCore.Quote.repUpdFields'. -- -- For example, suppose we have: --@@ -496,20 +498,20 @@  pprParendPat :: (OutputableBndrId p)              => PprPrec -> Pat (GhcPass p) -> SDoc-pprParendPat p pat = sdocWithDynFlags $ \ dflags ->-                     if need_parens dflags pat+pprParendPat p pat = sdocOption sdocPrintTypecheckerElaboration $ \print_tc_elab ->+                     if need_parens print_tc_elab pat                      then parens (pprPat pat)                      else  pprPat pat   where-    need_parens dflags pat-      | CoPat {} <- pat = gopt Opt_PrintTypecheckerElaboration dflags+    need_parens print_tc_elab pat+      | CoPat {} <- pat = print_tc_elab       | otherwise       = patNeedsParens p pat       -- For a CoPat we need parens if we are going to show it, which       -- we do if -fprint-typechecker-elaboration is on (c.f. pprHsWrapper)       -- But otherwise the CoPat is discarded, so it       -- is the pattern inside that matters.  Sigh. -pprPat :: (OutputableBndrId p) => Pat (GhcPass p) -> SDoc+pprPat :: forall p. (OutputableBndrId p) => Pat (GhcPass p) -> SDoc pprPat (VarPat _ lvar)          = pprPatBndr (unLoc lvar) pprPat (WildPat _)              = char '_' pprPat (LazyPat _ pat)          = char '~' <> pprParendLPat appPrec pat@@ -523,11 +525,16 @@ pprPat (NPat _ l (Just _) _)    = char '-' <> ppr l pprPat (NPlusKPat _ n k _ _ _)  = hcat [ppr n, char '+', ppr k] pprPat (SplicePat _ splice)     = pprSplice splice-pprPat (CoPat _ co pat _)       = pprHsWrapper co $ \parens-                                            -> if parens+pprPat (CoPat _ co pat _)       = pprIfTc @p $+                                  pprHsWrapper co $ \parens+                                              -> if parens                                                  then pprParendPat appPrec pat                                                  else pprPat pat-pprPat (SigPat _ pat ty)        = ppr pat <+> dcolon <+> ppr ty+pprPat (SigPat _ pat ty)        = ppr pat <+> dcolon <+> ppr_ty+  where ppr_ty = case ghcPass @p of+                   GhcPs -> ppr ty+                   GhcRn -> ppr ty+                   GhcTc -> ppr ty pprPat (ListPat _ pats)         = brackets (interpp'SP pats) pprPat (TuplePat _ pats bx)     -- Special-case unary boxed tuples so that they are pretty-printed as@@ -544,16 +551,15 @@                   , pat_dicts = dicts                   , pat_binds = binds                   , pat_args = details })-  = sdocWithDynFlags $ \dflags ->-       -- Tiresome; in TcBinds.tcRhs we print out a-       -- typechecked Pat in an error message,-       -- and we want to make sure it prints nicely-    if gopt Opt_PrintTypecheckerElaboration dflags then-        ppr con-          <> braces (sep [ hsep (map pprPatBndr (tvs ++ dicts))-                         , ppr binds])-          <+> pprConArgs details-    else pprUserCon (unLoc con) details+  = sdocOption sdocPrintTypecheckerElaboration $ \case+      False -> pprUserCon (unLoc con) details+      True  -> -- Tiresome; in TcBinds.tcRhs we print out a+               -- typechecked Pat in an error message,+               -- and we want to make sure it prints nicely+               ppr con+                  <> braces (sep [ hsep (map pprPatBndr (tvs ++ dicts))+                                 , pprIfTc @p $ ppr binds ])+                  <+> pprConArgs details pprPat (XPat n)                 = noExtCon n  @@ -729,6 +735,23 @@     go (SplicePat {})      = False      go (XPat {})           = False++-- | Is the pattern any of combination of:+--+-- - (pat)+-- - pat :: Type+-- - ~pat+-- - !pat+-- - x (variable)+isSimplePat :: LPat (GhcPass x) -> Maybe (IdP (GhcPass x))+isSimplePat p = case unLoc p of+  ParPat _ x -> isSimplePat x+  SigPat _ x _ -> isSimplePat x+  LazyPat _ x -> isSimplePat x+  BangPat _ x -> isSimplePat x+  VarPat _ x -> Just (unLoc x)+  _ -> Nothing+  {- Note [Unboxed sum patterns aren't irrefutable] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

compiler/GHC/Hs/Pat.hs-boot view

@@ -1,8 +1,8 @@ {-# LANGUAGE CPP, KindSignatures #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE RoleAnnotations #-} {-# LANGUAGE TypeFamilies #-}@@ -11,9 +11,10 @@  import Outputable import GHC.Hs.Extension ( OutputableBndrId, GhcPass, XRec )+import Data.Kind  type role Pat nominal-data Pat (i :: *)+data Pat (i :: Type) type LPat i = XRec i Pat  instance OutputableBndrId p => Outputable (Pat (GhcPass p))

− compiler/GHC/Hs/PlaceHolder.hs

@@ -1,70 +0,0 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE StandaloneDeriving #-}--module GHC.Hs.PlaceHolder where--import Name-import NameSet-import RdrName-import Var----{--%************************************************************************-%*                                                                      *-\subsection{Annotating the syntax}-%*                                                                      *-%************************************************************************--}---- NB: These are intentionally open, allowing API consumers (like Haddock)--- to declare new instances--placeHolderNamesTc :: NameSet-placeHolderNamesTc = emptyNameSet--{--TODO:AZ: remove this, and check if we still need all the UndecidableInstances--Note [Pass sensitive types]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Since the same AST types are re-used through parsing,renaming and type-checking there are naturally some places in the AST that do not have-any meaningful value prior to the pass they are assigned a value.--Historically these have been filled in with place holder values of the form--  panic "error message"--This has meant the AST is difficult to traverse using standard generic-programming techniques. The problem is addressed by introducing-pass-specific data types, implemented as a pair of open type families,-one for PostTc and one for PostRn. These are then explicitly populated-with a PlaceHolder value when they do not yet have meaning.--In terms of actual usage, we have the following--  PostTc id Kind-  PostTc id Type--  PostRn id Fixity-  PostRn id NameSet--TcId and Var are synonyms for Id--Unfortunately the type checker termination checking conditions fail for the-DataId constraint type based on this, so even though it is safe the-UndecidableInstances pragma is required where this is used.--}----- |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

compiler/GHC/Hs/Types.hs view

@@ -11,8 +11,8 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeSynonymInstances #-}-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]-                                      -- in module GHC.Hs.PlaceHolder+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]+                                      -- in module GHC.Hs.Extension {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-}@@ -327,7 +327,6 @@             , hsq_explicit :: [LHsTyVarBndr pass]                 -- Explicit variables, written by the user-                -- See Note [HsForAllTy tyvar binders]     }   | XLHsQTyVars (XXLHsQTyVars pass) @@ -761,29 +760,6 @@   {--Note [HsForAllTy tyvar binders]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-After parsing:-  * Implicit => empty-    Explicit => the variables the user wrote--After renaming-  * Implicit => the *type* variables free in the type-    Explicit => the variables the user wrote (renamed)--Qualified currently behaves exactly as Implicit,-but it is deprecated to use it for implicit quantification.-In this case, GHC 7.10 gives a warning; see-Note [Context quantification] in GHC.Rename.Types, and #4426.-In GHC 8.0, Qualified will no longer bind variables-and this will become an error.--The kind variables bound in the hsq_implicit field come both-  a) from the kind signatures on the kind vars (eg k1)-  b) from the scope of the forall (eg k2)-Example:   f :: forall (a::k1) b. T a (b::k2)-- Note [Unit tuples] ~~~~~~~~~~~~~~~~~~ Consider the type@@ -1345,7 +1321,6 @@   | XFieldOcc       (XXFieldOcc pass) deriving instance Eq  (XCFieldOcc (GhcPass p)) => Eq  (FieldOcc (GhcPass p))-deriving instance Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p))  type instance XCFieldOcc GhcPs = NoExtField type instance XCFieldOcc GhcRn = Name

compiler/GHC/Hs/Utils.hs view

@@ -38,7 +38,7 @@   mkLHsPar, mkHsCmdWrap, mkLHsCmdWrap,   mkHsCmdIf, -  nlHsTyApp, nlHsTyApps, nlHsVar, nlHsDataCon,+  nlHsTyApp, nlHsTyApps, nlHsVar, nl_HsVar, nlHsDataCon,   nlHsLit, nlHsApp, nlHsApps, nlHsSyntaxApps,   nlHsIntLit, nlHsVarApps,   nlHsDo, nlHsOpApp, nlHsLam, nlHsPar, nlHsIf, nlHsCase, nlList,@@ -107,7 +107,6 @@ import GHC.Hs.Pat import GHC.Hs.Types import GHC.Hs.Lit-import GHC.Hs.PlaceHolder import GHC.Hs.Extension  import TcEvidence@@ -151,7 +150,7 @@ mkHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) mkHsPar e = L (getLoc e) (HsPar noExtField e) -mkSimpleMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p)))+mkSimpleMatch :: HsMatchContext (NoGhcTc (GhcPass p))               -> [LPat (GhcPass p)] -> Located (body (GhcPass p))               -> LMatch (GhcPass p) (Located (body (GhcPass p))) mkSimpleMatch ctxt pats rhs@@ -215,18 +214,17 @@ mkHsCaseAlt pat expr   = mkSimpleMatch CaseAlt [pat] expr -nlHsTyApp :: IdP (GhcPass id) -> [Type] -> LHsExpr (GhcPass id)+nlHsTyApp :: Id -> [Type] -> LHsExpr GhcTc nlHsTyApp fun_id tys   = noLoc (mkHsWrap (mkWpTyApps tys) (HsVar noExtField (noLoc fun_id))) -nlHsTyApps :: IdP (GhcPass id) -> [Type] -> [LHsExpr (GhcPass id)]-           -> LHsExpr (GhcPass id)+nlHsTyApps :: Id -> [Type] -> [LHsExpr GhcTc] -> LHsExpr GhcTc nlHsTyApps fun_id tys xs = foldl' nlHsApp (nlHsTyApp fun_id tys) xs  --------- Adding parens --------- -- | Wrap in parens if @'hsExprNeedsParens' appPrec@ says it needs them -- So @f x@ becomes @(f x)@, but @3@ stays as @3@.-mkLHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)+mkLHsPar :: IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) mkLHsPar le@(L loc e)   | hsExprNeedsParens appPrec e = L loc (HsPar noExtField le)   | otherwise                   = le@@ -241,24 +239,26 @@  ------------------------------- -- These are the bits of syntax that contain rebindable names--- See GHC.Rename.Env.lookupSyntaxName+-- See GHC.Rename.Env.lookupSyntax  mkHsIntegral   :: IntegralLit -> HsOverLit GhcPs mkHsFractional :: FractionalLit -> HsOverLit GhcPs mkHsIsString   :: SourceText -> FastString -> HsOverLit GhcPs-mkHsDo         :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs-mkHsComp       :: HsStmtContext Name -> [ExprLStmt GhcPs] -> LHsExpr GhcPs+mkHsDo         :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> HsExpr GhcPs+mkHsComp       :: HsStmtContext GhcRn -> [ExprLStmt GhcPs] -> LHsExpr GhcPs                -> HsExpr GhcPs  mkNPat      :: Located (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs)             -> Pat GhcPs mkNPlusKPat :: Located RdrName -> Located (HsOverLit GhcPs) -> Pat GhcPs -mkLastStmt :: Located (bodyR (GhcPass idR))+-- NB: The following functions all use noSyntaxExpr: the generated expressions+--     will not work with rebindable syntax if used after the renamer+mkLastStmt :: IsPass idR => Located (bodyR (GhcPass idR))            -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) mkBodyStmt :: Located (bodyR GhcPs)            -> StmtLR (GhcPass idL) GhcPs (Located (bodyR GhcPs))-mkBindStmt :: (XBindStmt (GhcPass idL) (GhcPass idR)+mkBindStmt :: IsPass idR => (XBindStmt (GhcPass idL) (GhcPass idR)                          (Located (bodyR (GhcPass idR))) ~ NoExtField)            => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR))            -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR)))@@ -281,13 +281,14 @@   where     last_stmt = L (getLoc expr) $ mkLastStmt expr -mkHsIf :: LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)-       -> HsExpr (GhcPass p)-mkHsIf c a b = HsIf noExtField (Just noSyntaxExpr) c a b+-- restricted to GhcPs because other phases might need a SyntaxExpr+mkHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs+mkHsIf c a b = HsIf True {- this might use rebindable syntax -} noSyntaxExpr c a b+  -- see Note [Rebindable if] in Hs.Expr -mkHsCmdIf :: LHsExpr (GhcPass p) -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p)-       -> HsCmd (GhcPass p)-mkHsCmdIf c a b = HsCmdIf noExtField (Just noSyntaxExpr) c a b+-- restricted to GhcPs because other phases might need a SyntaxExpr+mkHsCmdIf :: LHsExpr GhcPs -> LHsCmd GhcPs -> LHsCmd GhcPs -> HsCmd GhcPs+mkHsCmdIf c a b = HsCmdIf noExtField noSyntaxExpr c a b  mkNPat lit neg     = NPat noExtField lit neg noSyntaxExpr mkNPlusKPat id lit@@ -323,8 +324,8 @@ mkTcBindStmt pat body = BindStmt unitTy pat body noSyntaxExpr noSyntaxExpr   -- don't use placeHolderTypeTc above, because that panics during zonking -emptyRecStmt' :: forall idL idR body.-                 XRecStmt (GhcPass idL) (GhcPass idR) body+emptyRecStmt' :: forall idL idR body. IsPass idR+              => XRecStmt (GhcPass idL) (GhcPass idR) body               -> StmtLR (GhcPass idL) (GhcPass idR) body emptyRecStmt' tyVal =    RecStmt@@ -389,6 +390,9 @@ nlHsVar :: IdP (GhcPass id) -> LHsExpr (GhcPass id) nlHsVar n = noLoc (HsVar noExtField (noLoc n)) +nl_HsVar :: IdP (GhcPass id) -> HsExpr (GhcPass id)+nl_HsVar n = HsVar noExtField (noLoc n)+ -- | NB: Only for 'LHsExpr' 'Id'. nlHsDataCon :: DataCon -> LHsExpr GhcTc nlHsDataCon con = noLoc (HsConLikeOut noExtField (RealDataCon con))@@ -405,23 +409,21 @@ nlLitPat :: HsLit GhcPs -> LPat GhcPs nlLitPat l = noLoc (LitPat noExtField l) -nlHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)+nlHsApp :: IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) nlHsApp f x = noLoc (HsApp noExtField f (mkLHsPar x)) -nlHsSyntaxApps :: SyntaxExpr (GhcPass id) -> [LHsExpr (GhcPass id)]-               -> LHsExpr (GhcPass id)-nlHsSyntaxApps (SyntaxExpr { syn_expr      = fun-                           , syn_arg_wraps = arg_wraps-                           , syn_res_wrap  = res_wrap }) args-  | [] <- arg_wraps   -- in the noSyntaxExpr case-  = ASSERT( isIdHsWrapper res_wrap )-    foldl' nlHsApp (noLoc fun) args--  | otherwise+nlHsSyntaxApps :: SyntaxExprTc -> [LHsExpr GhcTc]+               -> LHsExpr GhcTc+nlHsSyntaxApps (SyntaxExprTc { syn_expr      = fun+                             , syn_arg_wraps = arg_wraps+                             , syn_res_wrap  = res_wrap }) args   = mkLHsWrap res_wrap (foldl' nlHsApp (noLoc fun) (zipWithEqual "nlHsSyntaxApps"                                                      mkLHsWrap arg_wraps args))+nlHsSyntaxApps NoSyntaxExprTc args = pprPanic "nlHsSyntaxApps" (ppr args)+  -- this function should never be called in scenarios where there is no+  -- syntax expr -nlHsApps :: IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)+nlHsApps :: IsPass id => IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) nlHsApps f xs = foldl' nlHsApp (nlHsVar f) xs  nlHsVarApps :: IdP (GhcPass id) -> [IdP (GhcPass id)] -> LHsExpr (GhcPass id)@@ -465,7 +467,7 @@ nlWildPatName :: LPat GhcRn nlWildPatName  = noLoc (WildPat noExtField ) -nlHsDo :: HsStmtContext Name -> [LStmt GhcPs (LHsExpr GhcPs)]+nlHsDo :: HsStmtContext GhcRn -> [LStmt GhcPs (LHsExpr GhcPs)]        -> LHsExpr GhcPs nlHsDo ctxt stmts = noLoc (mkHsDo ctxt stmts) @@ -474,8 +476,6 @@  nlHsLam  :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs nlHsPar  :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)-nlHsIf   :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)-         -> LHsExpr (GhcPass id) nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)]          -> LHsExpr GhcPs nlList   :: [LHsExpr GhcPs] -> LHsExpr GhcPs@@ -483,10 +483,11 @@ nlHsLam match          = noLoc (HsLam noExtField (mkMatchGroup Generated [match])) nlHsPar e              = noLoc (HsPar noExtField e) --- | Note [Rebindable nlHsIf] -- nlHsIf should generate if-expressions which are NOT subject to--- RebindableSyntax, so the first field of HsIf is Nothing. (#12080)-nlHsIf cond true false = noLoc (HsIf noExtField Nothing cond true false)+-- RebindableSyntax, so the first field of HsIf is False. (#12080)+-- See Note [Rebindable if] in Hs.Expr+nlHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs+nlHsIf cond true false = noLoc (HsIf False noSyntaxExpr cond true false)  nlHsCase expr matches   = noLoc (HsCase noExtField expr (mkMatchGroup Generated matches))@@ -754,39 +755,40 @@ *                                                                      * ********************************************************************* -} -mkLHsWrap :: HsWrapper -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)+mkLHsWrap :: HsWrapper -> LHsExpr GhcTc -> LHsExpr GhcTc mkLHsWrap co_fn (L loc e) = L loc (mkHsWrap co_fn e) --- | Avoid @'HsWrap' co1 ('HsWrap' co2 _)@.--- See Note [Detecting forced eta expansion] in "DsExpr"-mkHsWrap :: HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)-mkHsWrap co_fn e | isIdHsWrapper co_fn = e-mkHsWrap co_fn (HsWrap _ co_fn' e)     = mkHsWrap (co_fn <.> co_fn') e-mkHsWrap co_fn e                       = HsWrap noExtField co_fn e+-- | Avoid @'HsWrap' co1 ('HsWrap' co2 _)@ and @'HsWrap' co1 ('HsPar' _ _)@+-- See Note [Detecting forced eta expansion] in "GHC.HsToCore.Expr"+mkHsWrap :: HsWrapper -> HsExpr GhcTc -> HsExpr GhcTc+mkHsWrap co_fn e | isIdHsWrapper co_fn   = e+mkHsWrap co_fn (XExpr (HsWrap co_fn' e)) = mkHsWrap (co_fn <.> co_fn') e+mkHsWrap co_fn (HsPar x (L l e))         = HsPar x (L l (mkHsWrap co_fn e))+mkHsWrap co_fn e                         = XExpr (HsWrap co_fn e)  mkHsWrapCo :: TcCoercionN   -- A Nominal coercion  a ~N b-           -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)+           -> HsExpr GhcTc -> HsExpr GhcTc mkHsWrapCo co e = mkHsWrap (mkWpCastN co) e  mkHsWrapCoR :: TcCoercionR   -- A Representational coercion  a ~R b-            -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)+            -> HsExpr GhcTc -> HsExpr GhcTc mkHsWrapCoR co e = mkHsWrap (mkWpCastR co) e -mkLHsWrapCo :: TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)+mkLHsWrapCo :: TcCoercionN -> LHsExpr GhcTc -> LHsExpr GhcTc mkLHsWrapCo co (L loc e) = L loc (mkHsWrapCo co e) -mkHsCmdWrap :: HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p)+mkHsCmdWrap :: HsWrapper -> HsCmd GhcTc -> HsCmd GhcTc mkHsCmdWrap w cmd | isIdHsWrapper w = cmd-                  | otherwise       = HsCmdWrap noExtField w cmd+                  | otherwise       = XCmd (HsWrap w cmd) -mkLHsCmdWrap :: HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p)+mkLHsCmdWrap :: HsWrapper -> LHsCmd GhcTc -> LHsCmd GhcTc mkLHsCmdWrap w (L loc c) = L loc (mkHsCmdWrap w c) -mkHsWrapPat :: HsWrapper -> Pat (GhcPass id) -> Type -> Pat (GhcPass id)+mkHsWrapPat :: HsWrapper -> Pat GhcTc -> Type -> Pat GhcTc mkHsWrapPat co_fn p ty | isIdHsWrapper co_fn = p                        | otherwise           = CoPat noExtField co_fn p ty -mkHsWrapPatCo :: TcCoercionN -> Pat (GhcPass id) -> Type -> Pat (GhcPass id)+mkHsWrapPatCo :: TcCoercionN -> Pat GhcTc -> Type -> Pat GhcTc mkHsWrapPatCo co pat ty | isTcReflCo co = pat                         | otherwise    = CoPat noExtField (mkWpCastN co) pat ty @@ -808,7 +810,6 @@ mkFunBind origin fn ms   = FunBind { fun_id = fn             , fun_matches = mkMatchGroup origin ms-            , fun_co_fn = idHsWrapper             , fun_ext = noExtField             , fun_tick = [] } @@ -817,7 +818,6 @@ -- ^ In Name-land, with empty bind_fvs mkTopFunBind origin fn ms = FunBind { fun_id = fn                                     , fun_matches = mkMatchGroup origin ms-                                    , fun_co_fn = idHsWrapper                                     , fun_ext  = emptyNameSet -- NB: closed                                                               --     binding                                     , fun_tick = [] }@@ -843,7 +843,7 @@ -- |If any of the matches in the 'FunBind' are infix, the 'FunBind' is -- considered infix. isInfixFunBind :: HsBindLR id1 id2 -> Bool-isInfixFunBind (FunBind _ _ (MG _ matches _) _ _)+isInfixFunBind (FunBind { fun_matches = MG _ matches _ })   = any (isInfixMatch . unLoc) (unLoc matches) isInfixFunBind _ = False @@ -859,13 +859,13 @@                        (noLoc emptyLocalBinds)]  -- | Make a prefix, non-strict function 'HsMatchContext'-mkPrefixFunRhs :: Located id -> HsMatchContext id+mkPrefixFunRhs :: LIdP p -> HsMatchContext p mkPrefixFunRhs n = FunRhs { mc_fun = n                           , mc_fixity = Prefix                           , mc_strictness = NoSrcStrict }  -------------mkMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p)))+mkMatch :: HsMatchContext (NoGhcTc (GhcPass p))         -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p)         -> Located (HsLocalBinds (GhcPass p))         -> LMatch (GhcPass p) (LHsExpr (GhcPass p))@@ -935,7 +935,7 @@ -- | Should we treat this as an unlifted bind? This will be true for any -- 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.+-- information, see Note [Strict binds check] is GHC.HsToCore.Binds. isUnliftedHsBind :: HsBind GhcTc -> Bool  -- works only over typechecked binds isUnliftedHsBind bind   | AbsBinds { abs_exports = exports, abs_sig = has_sig } <- bind@@ -1103,17 +1103,17 @@     go (XPat {})                  = bndrs  {--Note [Dictionary binders in ConPatOut] See also same Note in DsArrows+Note [Dictionary binders in ConPatOut] See also same Note in GHC.HsToCore.Arrows ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Do *not* gather (a) dictionary and (b) dictionary bindings as binders of a ConPatOut pattern.  For most calls it doesn't matter, because it's pre-typechecker and there are no ConPatOuts.  But it does matter-more in the desugarer; for example, DsUtils.mkSelectorBinds uses+more in the desugarer; for example, GHC.HsToCore.Utils.mkSelectorBinds uses collectPatBinders.  In a lazy pattern, for example f ~(C x y) = ..., we want to generate bindings for x,y but not for dictionaries bound by C.  (The type checker ensures they would not be used.) -Desugaring of arrow case expressions needs these bindings (see DsArrows+Desugaring of arrow case expressions needs these bindings (see GHC.HsToCore.Arrows and arrowcase1), but SPJ (Jan 2007) says it's safer for it to use its own pat-binder-collector: @@ -1127,7 +1127,7 @@ Here, the pattern (C (n+1)) binds a hidden dictionary (d::Num a), and *also* uses that dictionary to match the (n+1) pattern.  Yet, the variables bound by the lazy pattern are n,m, *not* the dictionary d.-So in mkSelectorBinds in DsUtils, we want just m,n as the variables bound.+So in mkSelectorBinds in GHC.HsToCore.Utils, we want just m,n as the variables bound. -}  hsGroupBinders :: HsGroup GhcRn -> [Name]

compiler/GHC/HsToCore/PmCheck/Types.hs view

@@ -29,7 +29,8 @@         setIndirectSDIE, setEntrySDIE, traverseSDIE,          -- * The pattern match oracle-        VarInfo(..), TmState(..), TyState(..), Delta(..), initDelta+        VarInfo(..), TmState(..), TyState(..), Delta(..),+        Deltas(..), initDeltas, liftDeltasM     ) where  #include "HsVersions.h"@@ -52,9 +53,9 @@ import Type import TyCon import Literal-import CoreSyn-import CoreMap-import CoreUtils (exprType)+import GHC.Core+import GHC.Core.Map+import GHC.Core.Utils (exprType) import PrelNames import TysWiredIn import TysPrim@@ -64,6 +65,7 @@ import Data.Foldable (find) import qualified Data.List.NonEmpty as NonEmpty import Data.Ratio+import qualified Data.Semigroup as Semi  -- | Literals (simple and overloaded ones) for pattern match checking. --@@ -146,7 +148,7 @@ eqConLike _                 _                 = PossiblyOverlap  -- | Represents the head of a match against a 'ConLike' or literal.--- Really similar to 'CoreSyn.AltCon'.+-- Really similar to 'GHC.Core.AltCon'. data PmAltCon = PmAltConLike ConLike               | PmAltLit     PmLit @@ -520,8 +522,7 @@ initTyState :: TyState initTyState = TySt emptyBag --- | Term and type constraints to accompany each value vector abstraction.--- For efficiency, we store the term oracle state instead of the term+-- | An inert set of canonical (i.e. mutually compatible) term and type -- constraints. data Delta = MkDelta { delta_ty_st :: TyState    -- Type oracle; things like a~Int                      , delta_tm_st :: TmState }  -- Term oracle; things like x~Nothing@@ -537,3 +538,18 @@       ppr (delta_tm_st delta),       ppr (delta_ty_st delta)     ]++-- | A disjunctive bag of 'Delta's, representing a refinement type.+newtype Deltas = MkDeltas (Bag Delta)++initDeltas :: Deltas+initDeltas = MkDeltas (unitBag initDelta)++instance Outputable Deltas where+  ppr (MkDeltas deltas) = ppr deltas++instance Semigroup Deltas where+  MkDeltas l <> MkDeltas r = MkDeltas (l `unionBags` r)++liftDeltasM :: Monad m => (Delta -> m (Maybe Delta)) -> Deltas -> m Deltas+liftDeltasM f (MkDeltas ds) = MkDeltas . catBagMaybes <$> (traverse f ds)

compiler/GHC/HsToCore/PmCheck/Types.hs-boot view

@@ -1,7 +1,9 @@ module GHC.HsToCore.PmCheck.Types where -import GhcPrelude ()+import Bag  data Delta -initDelta :: Delta+newtype Deltas = MkDeltas (Bag Delta)++initDeltas :: Deltas

compiler/GHC/Iface/Syntax.hs view

@@ -13,7 +13,7 @@         IfaceConDecl(..), IfaceConDecls(..), IfaceEqSpec,         IfaceExpr(..), IfaceAlt, IfaceLetBndr(..), IfaceJoinInfo(..),         IfaceBinding(..), IfaceConAlt(..),-        IfaceIdInfo(..), IfaceIdDetails(..), IfaceUnfolding(..),+        IfaceIdInfo, IfaceIdDetails(..), IfaceUnfolding(..),         IfaceInfoItem(..), IfaceRule(..), IfaceAnnotation(..), IfaceAnnTarget,         IfaceClsInst(..), IfaceFamInst(..), IfaceTickish(..),         IfaceClassBody(..),@@ -46,9 +46,9 @@  import GHC.Iface.Type import BinFingerprint-import CoreSyn( IsOrphan, isOrphan )-import DynFlags( gopt, GeneralFlag (Opt_PrintAxiomIncomps) )+import GHC.Core( IsOrphan, isOrphan ) import Demand+import Cpr import Class import FieldLabel import NameSet@@ -188,7 +188,7 @@   | IfDataInstance        IfExtName     -- Axiom name        IfaceTyCon    -- Family TyCon (pretty-printing only, not used in GHC.IfaceToCore)-                     -- see Note [Pretty printing via Iface syntax] in PprTyThing+                     -- see Note [Pretty printing via Iface syntax] in GHC.Core.Ppr.TyThing        IfaceAppArgs  -- Arguments of the family TyCon  data IfaceFamTyConFlav@@ -197,7 +197,7 @@   | IfaceClosedSynFamilyTyCon (Maybe (IfExtName, [IfaceAxBranch]))     -- ^ Name of associated axiom and branches for pretty printing purposes,     -- or 'Nothing' for an empty closed family without an axiom-    -- See Note [Pretty printing via Iface syntax] in PprTyThing+    -- See Note [Pretty printing via Iface syntax] in GHC.Core.Ppr.TyThing   | IfaceAbstractClosedSynFamilyTyCon   | IfaceBuiltInSynFamTyCon -- for pretty printing purposes only @@ -337,13 +337,12 @@ --   * The version comparison sees that new (=NoInfo) differs from old (=HasInfo *) --      and so gives a new version. -data IfaceIdInfo-  = NoInfo                      -- When writing interface file without -O-  | HasInfo [IfaceInfoItem]     -- Has info, and here it is+type IfaceIdInfo = [IfaceInfoItem]  data IfaceInfoItem   = HsArity         Arity   | HsStrictness    StrictSig+  | HsCpr           CprSig   | HsInline        InlinePragma   | HsUnfold        Bool             -- True <=> isStrongLoopBreaker is true                     IfaceUnfolding   -- See Note [Expose recursive functions]@@ -358,7 +357,9 @@                                 -- Possibly could eliminate the Bool here, the information                                 -- is also in the InlinePragma. -  | IfCompulsory IfaceExpr      -- Only used for default methods, in fact+  | IfCompulsory IfaceExpr      -- default methods and unsafeCoerce#+                                -- for more about unsafeCoerce#, see+                                -- Note [Wiring in unsafeCoerce#] in Desugar    | IfInlineRule Arity          -- INLINE pragmas                  Bool           -- OK to inline even if *un*-saturated@@ -400,10 +401,10 @@ --  *Excludes* the 'main' name, but *includes* the implicitly-bound names -- Deeply revolting, because it has to predict what gets bound, -- especially the question of whether there's a wrapper for a datacon--- See Note [Implicit TyThings] in HscTypes+-- See Note [Implicit TyThings] in GHC.Driver.Types  -- N.B. the set of names returned here *must* match the set of--- TyThings returned by HscTypes.implicitTyThings, in the sense that+-- TyThings returned by GHC.Driver.Types.implicitTyThings, in the sense that -- TyThing.getOccName should define a bijection between the two lists. -- This invariant is used in GHC.Iface.Load.loadDecl (see note [Tricky iface loop]) -- The order of the list does not matter.@@ -530,7 +531,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In Iface syntax an IfaceCase does not record the types of the alternatives, unlike Core syntax Case. But we need this type if the alternatives are empty.-Hence IfaceECase. See Note [Empty case alternatives] in CoreSyn.+Hence IfaceECase. See Note [Empty case alternatives] in GHC.Core.  Note [Expose recursive functions] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -546,7 +547,7 @@ function.  The user (Duncan Coutts) really wanted the NOINLINE control to cross the separate compilation boundary. -In general we retain all info that is left by CoreTidy.tidyLetBndr, since+In general we retain all info that is left by GHC.Core.Op.Tidy.tidyLetBndr, since that is what is seen by importing module with --make  Note [Displaying axiom incompatibilities]@@ -606,14 +607,13 @@      -- See Note [Displaying axiom incompatibilities]     maybe_index-      = sdocWithDynFlags $ \dflags ->-        ppWhen (gopt Opt_PrintAxiomIncomps dflags) $+      = ppWhenOption sdocPrintAxiomIncomps $           text "{-" <+> (text "#" <> ppr idx) <+> text "-}"     maybe_incomps-      = sdocWithDynFlags $ \dflags ->-        ppWhen (gopt Opt_PrintAxiomIncomps dflags && notNull incomps) $-          text "--" <+> text "incompatible with:"-          <+> pprWithCommas (\incomp -> text "#" <> ppr incomp) incomps+      = ppWhenOption sdocPrintAxiomIncomps $+          ppWhen (notNull incomps) $+            text "--" <+> text "incompatible with:"+            <+> pprWithCommas (\incomp -> text "#" <> ppr incomp) incomps  instance Outputable IfaceAnnotation where   ppr (IfaceAnnotation target value) = ppr target <+> colon <+> ppr value@@ -674,7 +674,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The binders in an IfaceDecl are just OccNames, so we don't know what module they come from.  But when we pretty-print a TyThing by converting to an IfaceDecl-(see PprTyThing), the TyThing may come from some other module so we really need+(see GHC.Core.Ppr.TyThing), the TyThing may come from some other module so we really need the module qualifier.  We solve this by passing in a pretty-printer for the binders. @@ -744,7 +744,7 @@  pprIfaceDecl :: ShowSub -> IfaceDecl -> SDoc -- NB: pprIfaceDecl is also used for pretty-printing TyThings in GHCi---     See Note [Pretty-printing TyThings] in PprTyThing+--     See Note [Pretty-printing TyThings] in GHC.Core.Ppr.TyThing pprIfaceDecl ss (IfaceData { ifName = tycon, ifCType = ctype,                              ifCtxt = context, ifResKind = kind,                              ifRoles = roles, ifCons = condecls,@@ -959,9 +959,9 @@                               ifPatProvCtxt = prov_ctxt, ifPatReqCtxt = req_ctxt,                               ifPatArgs = arg_tys,                               ifPatTy = pat_ty} )-  = sdocWithDynFlags mk_msg+  = sdocWithContext mk_msg   where-    mk_msg dflags+    mk_msg sdocCtx       = hang (text "pattern" <+> pprPrefixOcc name)            2 (dcolon <+> sep [univ_msg                              , pprIfaceContextArr req_ctxt@@ -974,7 +974,7 @@         ex_msg   = pprUserIfaceForAll ex_bndrs          insert_empty_ctxt = null req_ctxt-            && not (null prov_ctxt && isEmpty dflags ex_msg)+            && not (null prov_ctxt && isEmpty sdocCtx ex_msg)  pprIfaceDecl ss (IfaceId { ifName = var, ifType = ty,                               ifIdDetails = details, ifIdInfo = info })@@ -997,8 +997,8 @@ pprRoles :: (Role -> Bool) -> SDoc -> [IfaceTyConBinder]          -> [Role] -> SDoc pprRoles suppress_if tyCon bndrs roles-  = sdocWithDynFlags $ \dflags ->-      let froles = suppressIfaceInvisibles dflags bndrs roles+  = sdocOption sdocPrintExplicitKinds $ \print_kinds ->+      let froles = suppressIfaceInvisibles (PrintExplicitKinds print_kinds) bndrs roles       in ppUnless (all suppress_if froles || null froles) $          text "type role" <+> tyCon <+> hsep (map ppr froles) @@ -1060,11 +1060,11 @@                  -> [IfaceTyConBinder]   -- of the tycon, for invisible-suppression                  -> SDoc pprIfaceDeclHead suppress_sig context ss tc_occ bndrs-  = sdocWithDynFlags $ \ dflags ->+  = sdocOption sdocPrintExplicitKinds $ \print_kinds ->     sep [ pprIfaceContextArr context         , pprPrefixIfDeclBndr (ss_how_much ss) (occName tc_occ)           <+> pprIfaceTyConBinders suppress_sig-                (suppressIfaceInvisibles dflags bndrs bndrs) ]+                (suppressIfaceInvisibles (PrintExplicitKinds print_kinds) bndrs bndrs) ]  pprIfaceConDecl :: ShowSub -> Bool                 -> IfaceTopBndr@@ -1383,18 +1383,14 @@                                 else Outputable.empty   ppr IfDFunId          = text "DFunId" -instance Outputable IfaceIdInfo where-  ppr NoInfo       = Outputable.empty-  ppr (HasInfo is) = text "{-" <+> pprWithCommas ppr is-                     <+> text "-}"- instance Outputable IfaceInfoItem where   ppr (HsUnfold lb unf)     = text "Unfolding"                               <> ppWhen lb (text "(loop-breaker)")                               <> colon <+> ppr unf   ppr (HsInline prag)       = text "Inline:" <+> ppr prag   ppr (HsArity arity)       = text "Arity:" <+> int arity-  ppr (HsStrictness str) = text "Strictness:" <+> pprIfaceStrictSig str+  ppr (HsStrictness str)    = text "Strictness:" <+> pprIfaceStrictSig str+  ppr (HsCpr cpr)           = text "CPR:" <+> ppr cpr   ppr HsNoCafRefs           = text "HasNoCafRefs"   ppr HsLevity              = text "Never levity-polymorphic" @@ -1615,7 +1611,6 @@   = fnList freeNamesIfCoercion cos  freeNamesIfProv :: IfaceUnivCoProv -> NameSet-freeNamesIfProv IfaceUnsafeCoerceProv    = emptyNameSet freeNamesIfProv (IfacePhantomProv co)    = freeNamesIfCoercion co freeNamesIfProv (IfaceProofIrrelProv co) = freeNamesIfCoercion co freeNamesIfProv (IfacePluginProv _)      = emptyNameSet@@ -1648,8 +1643,7 @@ freeNamesIfIdBndr (_fs,k) = freeNamesIfKind k  freeNamesIfIdInfo :: IfaceIdInfo -> NameSet-freeNamesIfIdInfo NoInfo      = emptyNameSet-freeNamesIfIdInfo (HasInfo i) = fnList freeNamesItem i+freeNamesIfIdInfo = fnList freeNamesItem  freeNamesItem :: IfaceInfoItem -> NameSet freeNamesItem (HsUnfold _ u) = freeNamesIfUnfold u@@ -1739,7 +1733,7 @@      data DynFlags = DF ... PackageState ...     module Packages where-     import DynFlags+     import GHC.Driver.Session      data PackageState = PS ...      lookupModule (df :: DynFlags)         = case df of@@ -2151,16 +2145,6 @@             1 -> do { a <- get bh; b <- get bh; return (IfRecSelId a b) }             _ -> return IfDFunId -instance Binary IfaceIdInfo where-    put_ bh NoInfo      = putByte bh 0-    put_ bh (HasInfo i) = putByte bh 1 >> lazyPut bh i -- NB lazyPut--    get bh = do-        h <- getByte bh-        case h of-            0 -> return NoInfo-            _ -> liftM HasInfo $ lazyGet bh    -- NB lazyGet- instance Binary IfaceInfoItem where     put_ bh (HsArity aa)          = putByte bh 0 >> put_ bh aa     put_ bh (HsStrictness ab)     = putByte bh 1 >> put_ bh ab@@ -2168,6 +2152,7 @@     put_ bh (HsInline ad)         = putByte bh 3 >> put_ bh ad     put_ bh HsNoCafRefs           = putByte bh 4     put_ bh HsLevity              = putByte bh 5+    put_ bh (HsCpr cpr)           = putByte bh 6 >> put_ bh cpr     get bh = do         h <- getByte bh         case h of@@ -2178,7 +2163,8 @@                     return (HsUnfold lb ad)             3 -> liftM HsInline $ get bh             4 -> return HsNoCafRefs-            _ -> return HsLevity+            5 -> return HsLevity+            _ -> HsCpr <$> get bh  instance Binary IfaceUnfolding where     put_ bh (IfCoreUnfold s e) = do@@ -2500,11 +2486,6 @@     IfRecSelId (Right decl) b -> rnf decl `seq` rnf b     IfDFunId -> () -instance NFData IfaceIdInfo where-  rnf = \case-    NoInfo -> ()-    HasInfo f1 -> rnf f1- instance NFData IfaceInfoItem where   rnf = \case     HsArity a -> rnf a@@ -2513,6 +2494,7 @@     HsUnfold b unf -> rnf b `seq` rnf unf     HsNoCafRefs -> ()     HsLevity -> ()+    HsCpr cpr -> cpr `seq` ()  instance NFData IfaceUnfolding where   rnf = \case

compiler/GHC/Iface/Type.hs view

@@ -39,6 +39,7 @@         -- Printing         SuppressBndrSig(..),         UseBndrParens(..),+        PrintExplicitKinds(..),         pprIfaceType, pprParendIfaceType, pprPrecIfaceType,         pprIfaceContext, pprIfaceContextArr,         pprIfaceIdBndr, pprIfaceLamBndr, pprIfaceTvBndr, pprIfaceTyConBinders,@@ -65,7 +66,6 @@                                  , liftedRepDataConTyCon, tupleTyConName ) import {-# SOURCE #-} Type       ( isRuntimeRepTy ) -import DynFlags import TyCon hiding ( pprPromotionQuote ) import CoAxiom import Var@@ -137,7 +137,7 @@ -- | A kind of universal type, used for types and kinds. -- -- Any time a 'Type' is pretty-printed, it is first converted to an 'IfaceType'--- before being printed. See Note [Pretty printing via Iface syntax] in PprTyThing+-- before being printed. See Note [Pretty printing via Iface syntax] in GHC.Core.Ppr.TyThing data IfaceType   = IfaceFreeTyVar TyVar                -- See Note [Free tyvars in IfaceType]   | IfaceTyVar     IfLclName            -- Type/coercion variable only, not tycon@@ -237,12 +237,18 @@                       -- only: see Note [Equality predicates in IfaceType]                     deriving (Eq) +instance Outputable IfaceTyConSort where+  ppr IfaceNormalTyCon         = text "normal"+  ppr (IfaceTupleTyCon n sort) = ppr sort <> colon <> ppr n+  ppr (IfaceSumTyCon n)        = text "sum:" <> ppr n+  ppr IfaceEqualityTyCon       = text "equality"+ {- 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 pretty-print duplication, and it matches what we do with pretty--printing TyThings. See Note [Pretty printing via Iface syntax] in PprTyThing.+printing TyThings. See Note [Pretty printing via Iface syntax] in GHC.Core.Ppr.TyThing.  It works fine for closed types, but when printing debug traces (e.g. when using -ddump-tc-trace) we print a lot of /open/ types.  These@@ -350,8 +356,7 @@   | IfaceHoleCo       CoVar    -- ^ See Note [Holes in IfaceCoercion]  data IfaceUnivCoProv-  = IfaceUnsafeCoerceProv-  | IfacePhantomProv IfaceCoercion+  = IfacePhantomProv IfaceCoercion   | IfaceProofIrrelProv IfaceCoercion   | IfacePluginProv String @@ -417,10 +422,9 @@         = case split_rho ty2 of { (ps, tau) -> (ty1:ps, tau) }     split_rho tau = ([], tau) -suppressIfaceInvisibles :: DynFlags -> [IfaceTyConBinder] -> [a] -> [a]-suppressIfaceInvisibles dflags tys xs-  | gopt Opt_PrintExplicitKinds dflags = xs-  | otherwise = suppress tys xs+suppressIfaceInvisibles :: PrintExplicitKinds -> [IfaceTyConBinder] -> [a] -> [a]+suppressIfaceInvisibles (PrintExplicitKinds True) _tys xs = xs+suppressIfaceInvisibles (PrintExplicitKinds False) tys xs = suppress tys xs     where       suppress _       []      = []       suppress []      a       = a@@ -428,10 +432,10 @@         | 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+stripIfaceInvisVars :: PrintExplicitKinds -> [IfaceTyConBinder] -> [IfaceTyConBinder]+stripIfaceInvisVars (PrintExplicitKinds True)  tyvars = tyvars+stripIfaceInvisVars (PrintExplicitKinds False) tyvars+  = filterOut isInvisibleTyConBinder tyvars  -- | Extract an 'IfaceBndr' from an 'IfaceForAllBndr'. ifForAllBndrVar :: IfaceForAllBndr -> IfaceBndr@@ -525,7 +529,6 @@      go_cos = map go_co -    go_prov IfaceUnsafeCoerceProv    = IfaceUnsafeCoerceProv     go_prov (IfacePhantomProv co)    = IfacePhantomProv (go_co co)     go_prov (IfaceProofIrrelProv co) = IfaceProofIrrelProv (go_co co)     go_prov (IfacePluginProv str)    = IfacePluginProv str@@ -551,10 +554,9 @@ ************************************************************************ -} -stripInvisArgs :: DynFlags -> IfaceAppArgs -> IfaceAppArgs-stripInvisArgs dflags tys-  | gopt Opt_PrintExplicitKinds dflags = tys-  | otherwise = suppress_invis tys+stripInvisArgs :: PrintExplicitKinds -> IfaceAppArgs -> IfaceAppArgs+stripInvisArgs (PrintExplicitKinds True)  tys = tys+stripInvisArgs (PrintExplicitKinds False) tys = suppress_invis tys     where       suppress_invis c         = case c of@@ -687,10 +689,9 @@                    -> SDoc  -- ^ otherwise                    -> SDoc if_print_coercions yes no-  = sdocWithDynFlags $ \dflags ->+  = sdocOption sdocPrintExplicitCoercions $ \print_co ->     getPprStyle $ \style ->-    if gopt Opt_PrintExplicitCoercions dflags-         || dumpStyle style || debugStyle style+    if print_co || dumpStyle style || debugStyle style     then yes     else no @@ -753,7 +754,8 @@ -- See Note [Suppressing binder signatures] newtype SuppressBndrSig = SuppressBndrSig Bool -newtype UseBndrParens = UseBndrParens Bool+newtype UseBndrParens      = UseBndrParens Bool+newtype PrintExplicitKinds = PrintExplicitKinds Bool  pprIfaceTvBndr :: IfaceTvBndr -> SuppressBndrSig -> UseBndrParens -> SDoc pprIfaceTvBndr (tv, ki) (SuppressBndrSig suppress_sig) (UseBndrParens use_parens)@@ -853,12 +855,13 @@       ppr_app_ty_no_casts   where     ppr_app_ty =-        sdocWithDynFlags $ \dflags ->-        pprIfacePrefixApp ctxt_prec-                          (ppr_ty funPrec t)-                          (map (ppr_app_arg appPrec) (tys_wo_kinds dflags))+        sdocOption sdocPrintExplicitKinds $ \print_kinds ->+        let tys_wo_kinds = appArgsIfaceTypesArgFlags $ stripInvisArgs+                              (PrintExplicitKinds print_kinds) ts+        in pprIfacePrefixApp ctxt_prec+                             (ppr_ty funPrec t)+                             (map (ppr_app_arg appPrec) tys_wo_kinds) -    tys_wo_kinds dflags = appArgsIfaceTypesArgFlags $ stripInvisArgs dflags ts      -- Strip any casts from the head of the application     ppr_app_ty_no_casts =@@ -1009,9 +1012,9 @@  eliminateRuntimeRep :: (IfaceType -> SDoc) -> IfaceType -> SDoc eliminateRuntimeRep f ty-  = sdocWithDynFlags $ \dflags ->+  = sdocOption sdocPrintExplicitRuntimeReps $ \printExplicitRuntimeReps ->     getPprStyle      $ \sty    ->-    if userStyle sty && not (gopt Opt_PrintExplicitRuntimeReps dflags)+    if userStyle sty && not printExplicitRuntimeReps       then f (defaultRuntimeRepVars ty)       else f ty @@ -1032,9 +1035,8 @@ -- See Note [Pretty-printing invisible arguments] ppr_app_arg :: PprPrec -> (IfaceType, ArgFlag) -> SDoc ppr_app_arg ctx_prec (t, argf) =-  sdocWithDynFlags $ \dflags ->-  let print_kinds = gopt Opt_PrintExplicitKinds dflags-  in case argf of+  sdocOption sdocPrintExplicitKinds $ \print_kinds ->+  case argf of        Required  -> ppr_ty ctx_prec t        Specified |  print_kinds                  -> char '@' <> ppr_ty appPrec t@@ -1102,10 +1104,7 @@ pprIfaceForAllBndr bndr =   case bndr of     Bndr (IfaceTvBndr tv) Inferred ->-      sdocWithDynFlags $ \dflags ->-        if gopt Opt_PrintExplicitForalls dflags-        then braces $ pprIfaceTvBndr tv suppress_sig (UseBndrParens False)-        else pprIfaceTvBndr tv suppress_sig (UseBndrParens True)+      braces $ pprIfaceTvBndr tv suppress_sig (UseBndrParens False)     Bndr (IfaceTvBndr tv) _ ->       pprIfaceTvBndr tv suppress_sig (UseBndrParens True)     Bndr (IfaceIdBndr idv) _ -> pprIfaceIdBndr idv@@ -1134,11 +1133,11 @@  pprUserIfaceForAll :: [IfaceForAllBndr] -> SDoc pprUserIfaceForAll tvs-   = sdocWithDynFlags $ \dflags ->+   = sdocOption sdocPrintExplicitForalls $ \print_foralls ->      -- See Note [When to print foralls] in this module.      ppWhen (any tv_has_kind_var tvs              || any tv_is_required tvs-             || gopt Opt_PrintExplicitForalls dflags) $+             || print_foralls) $      pprIfaceForAll tvs    where      tv_has_kind_var (Bndr (IfaceTvBndr (_,kind)) _)@@ -1285,13 +1284,13 @@  pprTyTcApp :: PprPrec -> IfaceTyCon -> IfaceAppArgs -> SDoc pprTyTcApp ctxt_prec tc tys =-    sdocWithDynFlags $ \dflags ->+    sdocOption sdocPrintExplicitKinds $ \print_kinds ->     getPprStyle $ \style ->-    pprTyTcApp' ctxt_prec tc tys dflags style+    pprTyTcApp' ctxt_prec tc tys (PrintExplicitKinds print_kinds) style  pprTyTcApp' :: PprPrec -> IfaceTyCon -> IfaceAppArgs-            -> DynFlags -> PprStyle -> SDoc-pprTyTcApp' ctxt_prec tc tys dflags style+            -> PrintExplicitKinds -> PprStyle -> SDoc+pprTyTcApp' ctxt_prec tc tys printExplicitKinds style   | ifaceTyConName tc `hasKey` ipClassKey   , IA_Arg (IfaceLitTy (IfaceStrTyLit n))            Required (IA_Arg ty Required IA_Nil) <- tys@@ -1307,7 +1306,7 @@   = pprSum arity (ifaceTyConIsPromoted info) tys    | tc `ifaceTyConHasKey` consDataConKey-  , not (gopt Opt_PrintExplicitKinds dflags)+  , PrintExplicitKinds False <- printExplicitKinds   , IA_Arg _ argf (IA_Arg ty1 Required (IA_Arg ty2 Required IA_Nil)) <- tys   , isInvisibleArgFlag argf   = pprIfaceTyList ctxt_prec ty1 ty2@@ -1330,15 +1329,13 @@          -> ppr_iface_tc_app ppr_app_arg ctxt_prec tc tys_wo_kinds   where     info = ifaceTyConInfo tc-    tys_wo_kinds = appArgsIfaceTypesArgFlags $ stripInvisArgs dflags tys+    tys_wo_kinds = appArgsIfaceTypesArgFlags $ stripInvisArgs printExplicitKinds tys  ppr_kind_type :: PprPrec -> SDoc-ppr_kind_type ctxt_prec =-  sdocWithDynFlags $ \dflags ->-    if useStarIsType dflags-    then maybeParen ctxt_prec starPrec $-         unicodeSyntax (char '★') (char '*')-    else text "Type"+ppr_kind_type ctxt_prec = sdocOption sdocStarIsType $ \case+   False -> text "Type"+   True  -> maybeParen ctxt_prec starPrec $+              unicodeSyntax (char '★') (char '*')  -- | Pretty-print a type-level equality. -- Returns (Just doc) if the argument is a /saturated/ application@@ -1381,11 +1378,13 @@     nominal_eq_tc = tc_name `hasKey` heqTyConKey       -- (~~)                  || tc_name `hasKey` eqPrimTyConKey    -- (~#)     print_equality args =-        sdocWithDynFlags $ \dflags ->+        sdocOption sdocPrintExplicitKinds $ \print_kinds ->+        sdocOption sdocPrintEqualityRelations $ \print_eqs ->         getPprStyle      $ \style  ->-        print_equality' args style dflags+        print_equality' args print_kinds+          (print_eqs || dumpStyle style || debugStyle style) -    print_equality' (ki1, ki2, ty1, ty2) style dflags+    print_equality' (ki1, ki2, ty1, ty2) print_kinds print_eqs       | -- If -fprint-equality-relations is on, just print the original TyCon         print_eqs       = ppr_infix_eq (ppr tc)@@ -1420,11 +1419,7 @@               | otherwise               = pp opPrec ty -        print_kinds = gopt Opt_PrintExplicitKinds dflags-        print_eqs   = gopt Opt_PrintEqualityRelations dflags ||-                      dumpStyle style || debugStyle style - pprIfaceCoTcApp :: PprPrec -> IfaceTyCon -> [IfaceCoercion] -> SDoc pprIfaceCoTcApp ctxt_prec tc tys =   ppr_iface_tc_app (\prec (co, _) -> ppr_co prec co) ctxt_prec tc@@ -1562,11 +1557,6 @@ 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 appPrec $-    text "UnsafeCo" <+> ppr r <+>-    pprParendIfaceType ty1 <+> pprParendIfaceType ty2- ppr_co _ (IfaceUnivCo prov role ty1 ty2)   = text "Univ" <> (parens $       sep [ ppr role <+> pprIfaceUnivCoProv prov@@ -1610,8 +1600,6 @@  ------------------ pprIfaceUnivCoProv :: IfaceUnivCoProv -> SDoc-pprIfaceUnivCoProv IfaceUnsafeCoerceProv-  = text "unsafe" pprIfaceUnivCoProv (IfacePhantomProv co)   = text "phantom" <+> pprParendIfaceCoercion co pprIfaceUnivCoProv (IfaceProofIrrelProv co)@@ -1623,6 +1611,11 @@ instance Outputable IfaceTyCon where   ppr tc = pprPromotionQuote tc <> ppr (ifaceTyConName tc) +instance Outputable IfaceTyConInfo where+  ppr (IfaceTyConInfo { ifaceTyConIsPromoted = prom+                      , ifaceTyConSort       = sort })+    = angleBrackets $ ppr prom <> comma <+> ppr sort+ pprPromotionQuote :: IfaceTyCon -> SDoc pprPromotionQuote tc =     pprPromotionQuoteI $ ifaceTyConIsPromoted $ ifaceTyConInfo tc@@ -1954,26 +1947,24 @@            _ -> panic ("get IfaceCoercion " ++ show tag)  instance Binary IfaceUnivCoProv where-  put_ bh IfaceUnsafeCoerceProv = putByte bh 1   put_ bh (IfacePhantomProv a) = do-          putByte bh 2+          putByte bh 1           put_ bh a   put_ bh (IfaceProofIrrelProv a) = do-          putByte bh 3+          putByte bh 2           put_ bh a   put_ bh (IfacePluginProv a) = do-          putByte bh 4+          putByte bh 3           put_ bh a    get bh = do       tag <- getByte bh       case tag of-           1 -> return $ IfaceUnsafeCoerceProv-           2 -> do a <- get bh+           1 -> do a <- get bh                    return $ IfacePhantomProv a-           3 -> do a <- get bh+           2 -> do a <- get bh                    return $ IfaceProofIrrelProv a-           4 -> do a <- get bh+           3 -> do a <- get bh                    return $ IfacePluginProv a            _ -> panic ("get IfaceUnivCoProv " ++ show tag)

+ compiler/GHC/Platform/Reg.hs view

@@ -0,0 +1,241 @@+-- | An architecture independent description of a register.+--      This needs to stay architecture independent because it is used+--      by NCGMonad and the register allocators, which are shared+--      by all architectures.+--+module GHC.Platform.Reg (+        RegNo,+        Reg(..),+        regPair,+        regSingle,+        isRealReg,      takeRealReg,+        isVirtualReg,   takeVirtualReg,++        VirtualReg(..),+        renameVirtualReg,+        classOfVirtualReg,+        getHiVirtualRegFromLo,+        getHiVRegFromLo,++        RealReg(..),+        regNosOfRealReg,+        realRegsAlias,++        liftPatchFnToRegReg+)++where++import GhcPrelude++import Outputable+import Unique+import GHC.Platform.Reg.Class+import Data.List (intersect)++-- | An identifier for a primitive real machine register.+type RegNo+        = Int++-- VirtualRegs are virtual registers.  The register allocator will+--      eventually have to map them into RealRegs, or into spill slots.+--+--      VirtualRegs are allocated on the fly, usually to represent a single+--      value in the abstract assembly code (i.e. dynamic registers are+--      usually single assignment).+--+--      The  single assignment restriction isn't necessary to get correct code,+--      although a better register allocation will result if single+--      assignment is used -- because the allocator maps a VirtualReg into+--      a single RealReg, even if the VirtualReg has multiple live ranges.+--+--      Virtual regs can be of either class, so that info is attached.+--+data VirtualReg+        = VirtualRegI  {-# UNPACK #-} !Unique+        | VirtualRegHi {-# UNPACK #-} !Unique  -- High part of 2-word register+        | VirtualRegF  {-# UNPACK #-} !Unique+        | VirtualRegD  {-# UNPACK #-} !Unique++        deriving (Eq, Show)++-- This is laborious, but necessary. We can't derive Ord because+-- Unique doesn't have an Ord instance. Note nonDetCmpUnique in the+-- implementation. See Note [No Ord for Unique]+-- This is non-deterministic but we do not currently support deterministic+-- code-generation. See Note [Unique Determinism and code generation]+instance Ord VirtualReg where+  compare (VirtualRegI a) (VirtualRegI b) = nonDetCmpUnique a b+  compare (VirtualRegHi a) (VirtualRegHi b) = nonDetCmpUnique a b+  compare (VirtualRegF a) (VirtualRegF b) = nonDetCmpUnique a b+  compare (VirtualRegD a) (VirtualRegD b) = nonDetCmpUnique a b++  compare VirtualRegI{} _ = LT+  compare _ VirtualRegI{} = GT+  compare VirtualRegHi{} _ = LT+  compare _ VirtualRegHi{} = GT+  compare VirtualRegF{} _ = LT+  compare _ VirtualRegF{} = GT++++instance Uniquable VirtualReg where+        getUnique reg+         = case reg of+                VirtualRegI u   -> u+                VirtualRegHi u  -> u+                VirtualRegF u   -> u+                VirtualRegD u   -> u++instance Outputable VirtualReg where+        ppr reg+         = case reg of+                VirtualRegI  u  -> text "%vI_"   <> pprUniqueAlways u+                VirtualRegHi u  -> text "%vHi_"  <> pprUniqueAlways u+                -- this code is kinda wrong on x86+                -- because float and double occupy the same register set+                -- namely SSE2 register xmm0 .. xmm15+                VirtualRegF  u  -> text "%vFloat_"   <> pprUniqueAlways u+                VirtualRegD  u  -> text "%vDouble_"   <> pprUniqueAlways u++++renameVirtualReg :: Unique -> VirtualReg -> VirtualReg+renameVirtualReg u r+ = case r of+        VirtualRegI _   -> VirtualRegI  u+        VirtualRegHi _  -> VirtualRegHi u+        VirtualRegF _   -> VirtualRegF  u+        VirtualRegD _   -> VirtualRegD  u+++classOfVirtualReg :: VirtualReg -> RegClass+classOfVirtualReg vr+ = case vr of+        VirtualRegI{}   -> RcInteger+        VirtualRegHi{}  -> RcInteger+        VirtualRegF{}   -> RcFloat+        VirtualRegD{}   -> RcDouble++++-- Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform+-- when supplied with the vreg for the lower-half of the quantity.+-- (NB. Not reversible).+getHiVirtualRegFromLo :: VirtualReg -> VirtualReg+getHiVirtualRegFromLo reg+ = case reg of+        -- makes a pseudo-unique with tag 'H'+        VirtualRegI u   -> VirtualRegHi (newTagUnique u 'H')+        _               -> panic "Reg.getHiVirtualRegFromLo"++getHiVRegFromLo :: Reg -> Reg+getHiVRegFromLo reg+ = case reg of+        RegVirtual  vr  -> RegVirtual (getHiVirtualRegFromLo vr)+        RegReal _       -> panic "Reg.getHiVRegFromLo"+++------------------------------------------------------------------------------------+-- | RealRegs are machine regs which are available for allocation, in+--      the usual way.  We know what class they are, because that's part of+--      the processor's architecture.+--+--      RealRegPairs are pairs of real registers that are allocated together+--      to hold a larger value, such as with Double regs on SPARC.+--+data RealReg+        = RealRegSingle {-# UNPACK #-} !RegNo+        | RealRegPair   {-# UNPACK #-} !RegNo {-# UNPACK #-} !RegNo+        deriving (Eq, Show, Ord)++instance Uniquable RealReg where+        getUnique reg+         = case reg of+                RealRegSingle i         -> mkRegSingleUnique i+                RealRegPair r1 r2       -> mkRegPairUnique (r1 * 65536 + r2)++instance Outputable RealReg where+        ppr reg+         = case reg of+                RealRegSingle i         -> text "%r"  <> int i+                RealRegPair r1 r2       -> text "%r(" <> int r1+                                           <> vbar <> int r2 <> text ")"++regNosOfRealReg :: RealReg -> [RegNo]+regNosOfRealReg rr+ = case rr of+        RealRegSingle r1        -> [r1]+        RealRegPair   r1 r2     -> [r1, r2]+++realRegsAlias :: RealReg -> RealReg -> Bool+realRegsAlias rr1 rr2+        = not $ null $ intersect (regNosOfRealReg rr1) (regNosOfRealReg rr2)++--------------------------------------------------------------------------------+-- | A register, either virtual or real+data Reg+        = RegVirtual !VirtualReg+        | RegReal    !RealReg+        deriving (Eq, Ord)++regSingle :: RegNo -> Reg+regSingle regNo         = RegReal $ RealRegSingle regNo++regPair :: RegNo -> RegNo -> Reg+regPair regNo1 regNo2   = RegReal $ RealRegPair regNo1 regNo2+++-- We like to have Uniques for Reg so that we can make UniqFM and UniqSets+-- in the register allocator.+instance Uniquable Reg where+        getUnique reg+         = case reg of+                RegVirtual vr   -> getUnique vr+                RegReal    rr   -> getUnique rr++-- | Print a reg in a generic manner+--      If you want the architecture specific names, then use the pprReg+--      function from the appropriate Ppr module.+instance Outputable Reg where+        ppr reg+         = case reg of+                RegVirtual vr   -> ppr vr+                RegReal    rr   -> ppr rr+++isRealReg :: Reg -> Bool+isRealReg reg+ = case reg of+        RegReal _       -> True+        RegVirtual _    -> False++takeRealReg :: Reg -> Maybe RealReg+takeRealReg reg+ = case reg of+        RegReal rr      -> Just rr+        _               -> Nothing+++isVirtualReg :: Reg -> Bool+isVirtualReg reg+ = case reg of+        RegReal _       -> False+        RegVirtual _    -> True++takeVirtualReg :: Reg -> Maybe VirtualReg+takeVirtualReg reg+ = case reg of+        RegReal _       -> Nothing+        RegVirtual vr   -> Just vr+++-- | The patch function supplied by the allocator maps VirtualReg to RealReg+--      regs, but sometimes we want to apply it to plain old Reg.+--+liftPatchFnToRegReg  :: (VirtualReg -> RealReg) -> (Reg -> Reg)+liftPatchFnToRegReg patchF reg+ = case reg of+        RegVirtual vr   -> RegReal (patchF vr)+        RegReal _       -> reg

+ compiler/GHC/Platform/Reg/Class.hs view

@@ -0,0 +1,32 @@+-- | An architecture independent description of a register's class.+module GHC.Platform.Reg.Class+        ( RegClass (..) )++where++import GhcPrelude++import  Outputable+import  Unique+++-- | The class of a register.+--      Used in the register allocator.+--      We treat all registers in a class as being interchangeable.+--+data RegClass+        = RcInteger+        | RcFloat+        | RcDouble+        deriving Eq+++instance Uniquable RegClass where+    getUnique RcInteger = mkRegClassUnique 0+    getUnique RcFloat   = mkRegClassUnique 1+    getUnique RcDouble  = mkRegClassUnique 2++instance Outputable RegClass where+    ppr RcInteger       = Outputable.text "I"+    ppr RcFloat         = Outputable.text "F"+    ppr RcDouble        = Outputable.text "D"

compiler/GHC/Platform/Regs.hs view

@@ -7,7 +7,7 @@  import GHC.Cmm.Expr import GHC.Platform-import Reg+import GHC.Platform.Reg  import qualified GHC.Platform.ARM        as ARM import qualified GHC.Platform.ARM64      as ARM64

+ compiler/GHC/Runtime/Eval/Types.hs view

@@ -0,0 +1,89 @@+-- -----------------------------------------------------------------------------+--+-- (c) The University of Glasgow, 2005-2007+--+-- Running statements interactively+--+-- -----------------------------------------------------------------------------++module GHC.Runtime.Eval.Types (+        Resume(..), History(..), ExecResult(..),+        SingleStep(..), isStep, ExecOptions(..),+        BreakInfo(..)+        ) where++import GhcPrelude++import GHCi.RemoteTypes+import GHCi.Message (EvalExpr, ResumeContext)+import Id+import Name+import Module+import RdrName+import Type+import SrcLoc+import Exception++import Data.Word+import GHC.Stack.CCS++data ExecOptions+ = ExecOptions+     { execSingleStep :: SingleStep         -- ^ stepping mode+     , execSourceFile :: String             -- ^ filename (for errors)+     , execLineNumber :: Int                -- ^ line number (for errors)+     , execWrap :: ForeignHValue -> EvalExpr ForeignHValue+     }++data SingleStep+   = RunToCompletion+   | SingleStep+   | RunAndLogSteps++isStep :: SingleStep -> Bool+isStep RunToCompletion = False+isStep _ = True++data ExecResult+  = ExecComplete+       { execResult :: Either SomeException [Name]+       , execAllocation :: Word64+       }+  | ExecBreak+       { breakNames :: [Name]+       , breakInfo :: Maybe BreakInfo+       }++data BreakInfo = BreakInfo+  { breakInfo_module :: Module+  , breakInfo_number :: Int+  }++data Resume = Resume+       { resumeStmt      :: String       -- the original statement+       , resumeContext   :: ForeignRef (ResumeContext [HValueRef])+       , resumeBindings  :: ([TyThing], GlobalRdrEnv)+       , resumeFinalIds  :: [Id]         -- [Id] to bind on completion+       , resumeApStack   :: ForeignHValue -- The object from which we can get+                                        -- value of the free variables.+       , resumeBreakInfo :: Maybe BreakInfo+                                        -- the breakpoint we stopped at+                                        -- (module, index)+                                        -- (Nothing <=> exception)+       , resumeSpan      :: SrcSpan      -- just a copy of the SrcSpan+                                        -- from the ModBreaks,+                                        -- otherwise it's a pain to+                                        -- fetch the ModDetails &+                                        -- ModBreaks to get this.+       , resumeDecl      :: String       -- ditto+       , resumeCCS       :: RemotePtr CostCentreStack+       , resumeHistory   :: [History]+       , resumeHistoryIx :: Int           -- 0 <==> at the top of the history+       }++data History+   = History {+        historyApStack   :: ForeignHValue,+        historyBreakInfo :: BreakInfo,+        historyEnclosingDecls :: [String]  -- declarations enclosing the breakpoint+   }

+ compiler/GHC/Runtime/Heap/Layout.hs view

@@ -0,0 +1,563 @@+-- (c) The University of Glasgow 2006+-- (c) The GRASP/AQUA Project, Glasgow University, 1992-1998+--+-- Storage manager representation of closures++{-# LANGUAGE CPP,GeneralizedNewtypeDeriving #-}++module GHC.Runtime.Heap.Layout (+        -- * Words and bytes+        WordOff, ByteOff,+        wordsToBytes, bytesToWordsRoundUp,+        roundUpToWords, roundUpTo,++        StgWord, fromStgWord, toStgWord,+        StgHalfWord, fromStgHalfWord, toStgHalfWord,+        halfWordSize, halfWordSizeInBits,++        -- * Closure representation+        SMRep(..), -- CmmInfo sees the rep; no one else does+        IsStatic,+        ClosureTypeInfo(..), ArgDescr(..), Liveness,+        ConstrDescription,++        -- ** Construction+        mkHeapRep, blackHoleRep, indStaticRep, mkStackRep, mkRTSRep, arrPtrsRep,+        smallArrPtrsRep, arrWordsRep,++        -- ** Predicates+        isStaticRep, isConRep, isThunkRep, isFunRep, isStaticNoCafCon,+        isStackRep,++        -- ** Size-related things+        heapClosureSizeW,+        fixedHdrSizeW, arrWordsHdrSize, arrWordsHdrSizeW, arrPtrsHdrSize,+        arrPtrsHdrSizeW, profHdrSize, thunkHdrSize, nonHdrSize, nonHdrSizeW,+        smallArrPtrsHdrSize, smallArrPtrsHdrSizeW, hdrSize, hdrSizeW,+        fixedHdrSize,++        -- ** RTS closure types+        rtsClosureType, rET_SMALL, rET_BIG,+        aRG_GEN, aRG_GEN_BIG,++        -- ** Arrays+        card, cardRoundUp, cardTableSizeB, cardTableSizeW+    ) where++import GhcPrelude++import BasicTypes( ConTagZ )+import GHC.Driver.Session+import Outputable+import GHC.Platform+import FastString++import Data.Word+import Data.Bits+import Data.ByteString (ByteString)++{-+************************************************************************+*                                                                      *+                Words and bytes+*                                                                      *+************************************************************************+-}++-- | Word offset, or word count+type WordOff = Int++-- | Byte offset, or byte count+type ByteOff = Int++-- | 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 = 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+-- a@ to allow for overloading.+wordsToBytes :: Num a => DynFlags -> a -> a+wordsToBytes dflags n = fromIntegral (wORD_SIZE dflags) * n+{-# SPECIALIZE wordsToBytes :: DynFlags -> Int -> Int #-}+{-# SPECIALIZE wordsToBytes :: DynFlags -> Word -> Word #-}+{-# SPECIALIZE wordsToBytes :: DynFlags -> Integer -> Integer #-}++-- | First round the given byte count up to a multiple of the+-- machine's word size and then convert the result to words.+bytesToWordsRoundUp :: DynFlags -> ByteOff -> WordOff+bytesToWordsRoundUp dflags n = (n + word_size - 1) `quot` word_size+ where word_size = wORD_SIZE dflags+-- StgWord is a type representing an StgWord on the target platform.+-- A Word64 is large enough to hold a Word for either a 32bit or 64bit platform+newtype StgWord = StgWord Word64+    deriving (Eq, Bits)++fromStgWord :: StgWord -> Integer+fromStgWord (StgWord i) = toInteger i++toStgWord :: DynFlags -> Integer -> StgWord+toStgWord dflags i+    = case platformWordSize (targetPlatform dflags) of+      -- These conversions mean that things like toStgWord (-1)+      -- do the right thing+      PW4 -> StgWord (fromIntegral (fromInteger i :: Word32))+      PW8 -> StgWord (fromInteger i)++instance Outputable StgWord where+    ppr (StgWord i) = integer (toInteger i)++--++-- A Word32 is large enough to hold half a Word for either a 32bit or+-- 64bit platform+newtype StgHalfWord = StgHalfWord Word32+    deriving Eq++fromStgHalfWord :: StgHalfWord -> Integer+fromStgHalfWord (StgHalfWord w) = toInteger w++toStgHalfWord :: DynFlags -> Integer -> StgHalfWord+toStgHalfWord dflags i+    = case platformWordSize (targetPlatform dflags) of+      -- These conversions mean that things like toStgHalfWord (-1)+      -- do the right thing+      PW4 -> StgHalfWord (fromIntegral (fromInteger i :: Word16))+      PW8 -> StgHalfWord (fromInteger i :: Word32)++instance Outputable StgHalfWord where+    ppr (StgHalfWord w) = integer (toInteger w)++-- | Half word size in bytes+halfWordSize :: DynFlags -> ByteOff+halfWordSize dflags = platformWordSizeInBytes (targetPlatform dflags) `div` 2++halfWordSizeInBits :: DynFlags -> Int+halfWordSizeInBits dflags = platformWordSizeInBits (targetPlatform dflags) `div` 2++{-+************************************************************************+*                                                                      *+\subsubsection[SMRep-datatype]{@SMRep@---storage manager representation}+*                                                                      *+************************************************************************+-}++-- | A description of the layout of a closure.  Corresponds directly+-- to the closure types in includes/rts/storage/ClosureTypes.h.+data SMRep+  = HeapRep              -- GC routines consult sizes in info tbl+        IsStatic+        !WordOff         --  # ptr words+        !WordOff         --  # non-ptr words INCLUDING SLOP (see mkHeapRep below)+        ClosureTypeInfo  -- type-specific info++  | ArrayPtrsRep+        !WordOff        -- # ptr words+        !WordOff        -- # card table words++  | SmallArrayPtrsRep+        !WordOff        -- # ptr words++  | ArrayWordsRep+        !WordOff        -- # bytes expressed in words, rounded up++  | StackRep            -- Stack frame (RET_SMALL or RET_BIG)+        Liveness++  | RTSRep              -- The RTS needs to declare info tables with specific+        Int             -- type tags, so this form lets us override the default+        SMRep           -- tag for an SMRep.++-- | True <=> This is a static closure.  Affects how we garbage-collect it.+-- Static closure have an extra static link field at the end.+-- Constructors do not have a static variant; see Note [static constructors]+type IsStatic = Bool++-- From an SMRep you can get to the closure type defined in+-- includes/rts/storage/ClosureTypes.h. Described by the function+-- rtsClosureType below.++data ClosureTypeInfo+  = Constr        ConTagZ ConstrDescription+  | Fun           FunArity ArgDescr+  | Thunk+  | ThunkSelector SelectorOffset+  | BlackHole+  | IndStatic++type ConstrDescription = ByteString -- result of dataConIdentity+type FunArity          = Int+type SelectorOffset    = Int++-------------------------+-- We represent liveness bitmaps as a Bitmap (whose internal+-- representation really is a bitmap).  These are pinned onto case return+-- vectors to indicate the state of the stack for the garbage collector.+--+-- In the compiled program, liveness bitmaps that fit inside a single+-- word (StgWord) are stored as a single word, while larger bitmaps are+-- stored as a pointer to an array of words.++type Liveness = [Bool]   -- One Bool per word; True  <=> non-ptr or dead+                         --                    False <=> ptr++-------------------------+-- An ArgDescr describes the argument pattern of a function++data ArgDescr+  = ArgSpec             -- Fits one of the standard patterns+        !Int            -- RTS type identifier ARG_P, ARG_N, ...++  | ArgGen              -- General case+        Liveness        -- Details about the arguments+++-----------------------------------------------------------------------------+-- Construction++mkHeapRep :: DynFlags -> IsStatic -> WordOff -> WordOff -> ClosureTypeInfo+          -> SMRep+mkHeapRep dflags is_static ptr_wds nonptr_wds cl_type_info+  = HeapRep is_static+            ptr_wds+            (nonptr_wds + slop_wds)+            cl_type_info+  where+     slop_wds+      | is_static = 0+      | otherwise = max 0 (minClosureSize dflags - (hdr_size + payload_size))++     hdr_size     = closureTypeHdrSize dflags cl_type_info+     payload_size = ptr_wds + nonptr_wds++mkRTSRep :: Int -> SMRep -> SMRep+mkRTSRep = RTSRep++mkStackRep :: [Bool] -> SMRep+mkStackRep liveness = StackRep liveness++blackHoleRep :: SMRep+blackHoleRep = HeapRep False 0 0 BlackHole++indStaticRep :: SMRep+indStaticRep = HeapRep True 1 0 IndStatic++arrPtrsRep :: DynFlags -> WordOff -> SMRep+arrPtrsRep dflags elems = ArrayPtrsRep elems (cardTableSizeW dflags elems)++smallArrPtrsRep :: WordOff -> SMRep+smallArrPtrsRep elems = SmallArrayPtrsRep elems++arrWordsRep :: DynFlags -> ByteOff -> SMRep+arrWordsRep dflags bytes = ArrayWordsRep (bytesToWordsRoundUp dflags bytes)++-----------------------------------------------------------------------------+-- Predicates++isStaticRep :: SMRep -> IsStatic+isStaticRep (HeapRep is_static _ _ _) = is_static+isStaticRep (RTSRep _ rep)            = isStaticRep rep+isStaticRep _                         = False++isStackRep :: SMRep -> Bool+isStackRep StackRep{}     = True+isStackRep (RTSRep _ rep) = isStackRep rep+isStackRep _              = False++isConRep :: SMRep -> Bool+isConRep (HeapRep _ _ _ Constr{}) = True+isConRep _                        = False++isThunkRep :: SMRep -> Bool+isThunkRep (HeapRep _ _ _ Thunk)           = True+isThunkRep (HeapRep _ _ _ ThunkSelector{}) = True+isThunkRep (HeapRep _ _ _ BlackHole)       = True+isThunkRep (HeapRep _ _ _ IndStatic)       = True+isThunkRep _                               = False++isFunRep :: SMRep -> Bool+isFunRep (HeapRep _ _ _ Fun{}) = True+isFunRep _                     = False++isStaticNoCafCon :: SMRep -> Bool+-- This should line up exactly with CONSTR_NOCAF below+-- See Note [Static NoCaf constructors]+isStaticNoCafCon (HeapRep _ 0 _ Constr{}) = True+isStaticNoCafCon _                        = False+++-----------------------------------------------------------------------------+-- Size-related things++fixedHdrSize :: DynFlags -> ByteOff+fixedHdrSize dflags = wordsToBytes dflags (fixedHdrSizeW dflags)++-- | Size of a closure header (StgHeader in includes/rts/storage/Closures.h)+fixedHdrSizeW :: DynFlags -> WordOff+fixedHdrSizeW dflags = sTD_HDR_SIZE dflags + profHdrSize dflags++-- | Size of the profiling part of a closure header+-- (StgProfHeader in includes/rts/storage/Closures.h)+profHdrSize  :: DynFlags -> WordOff+profHdrSize dflags+ | gopt Opt_SccProfilingOn dflags = pROF_HDR_SIZE dflags+ | otherwise                      = 0++-- | The garbage collector requires that every closure is at least as+--   big as this.+minClosureSize :: DynFlags -> WordOff+minClosureSize dflags = fixedHdrSizeW dflags + mIN_PAYLOAD_SIZE dflags++arrWordsHdrSize :: DynFlags -> ByteOff+arrWordsHdrSize dflags+ = fixedHdrSize dflags + sIZEOF_StgArrBytes_NoHdr dflags++arrWordsHdrSizeW :: DynFlags -> WordOff+arrWordsHdrSizeW dflags =+    fixedHdrSizeW dflags ++    (sIZEOF_StgArrBytes_NoHdr dflags `quot` wORD_SIZE dflags)++arrPtrsHdrSize :: DynFlags -> ByteOff+arrPtrsHdrSize dflags+ = fixedHdrSize dflags + sIZEOF_StgMutArrPtrs_NoHdr dflags++arrPtrsHdrSizeW :: DynFlags -> WordOff+arrPtrsHdrSizeW dflags =+    fixedHdrSizeW dflags ++    (sIZEOF_StgMutArrPtrs_NoHdr dflags `quot` wORD_SIZE dflags)++smallArrPtrsHdrSize :: DynFlags -> ByteOff+smallArrPtrsHdrSize dflags+ = fixedHdrSize dflags + sIZEOF_StgSmallMutArrPtrs_NoHdr dflags++smallArrPtrsHdrSizeW :: DynFlags -> WordOff+smallArrPtrsHdrSizeW dflags =+    fixedHdrSizeW dflags ++    (sIZEOF_StgSmallMutArrPtrs_NoHdr dflags `quot` wORD_SIZE dflags)++-- Thunks have an extra header word on SMP, so the update doesn't+-- splat the payload.+thunkHdrSize :: DynFlags -> WordOff+thunkHdrSize dflags = fixedHdrSizeW dflags + smp_hdr+        where smp_hdr = sIZEOF_StgSMPThunkHeader dflags `quot` wORD_SIZE dflags++hdrSize :: DynFlags -> SMRep -> ByteOff+hdrSize dflags rep = wordsToBytes dflags (hdrSizeW dflags rep)++hdrSizeW :: DynFlags -> SMRep -> WordOff+hdrSizeW dflags (HeapRep _ _ _ ty)    = closureTypeHdrSize dflags ty+hdrSizeW dflags (ArrayPtrsRep _ _)    = arrPtrsHdrSizeW dflags+hdrSizeW dflags (SmallArrayPtrsRep _) = smallArrPtrsHdrSizeW dflags+hdrSizeW dflags (ArrayWordsRep _)     = arrWordsHdrSizeW dflags+hdrSizeW _ _                          = panic "SMRep.hdrSizeW"++nonHdrSize :: DynFlags -> SMRep -> ByteOff+nonHdrSize dflags rep = wordsToBytes dflags (nonHdrSizeW rep)++nonHdrSizeW :: SMRep -> WordOff+nonHdrSizeW (HeapRep _ p np _) = p + np+nonHdrSizeW (ArrayPtrsRep elems ct) = elems + ct+nonHdrSizeW (SmallArrayPtrsRep elems) = elems+nonHdrSizeW (ArrayWordsRep words) = words+nonHdrSizeW (StackRep bs)      = length bs+nonHdrSizeW (RTSRep _ rep)     = nonHdrSizeW rep++-- | The total size of the closure, in words.+heapClosureSizeW :: DynFlags -> SMRep -> WordOff+heapClosureSizeW dflags (HeapRep _ p np ty)+ = closureTypeHdrSize dflags ty + p + np+heapClosureSizeW dflags (ArrayPtrsRep elems ct)+ = arrPtrsHdrSizeW dflags + elems + ct+heapClosureSizeW dflags (SmallArrayPtrsRep elems)+ = smallArrPtrsHdrSizeW dflags + elems+heapClosureSizeW dflags (ArrayWordsRep words)+ = arrWordsHdrSizeW dflags + words+heapClosureSizeW _ _ = panic "SMRep.heapClosureSize"++closureTypeHdrSize :: DynFlags -> ClosureTypeInfo -> WordOff+closureTypeHdrSize dflags ty = case ty of+                  Thunk           -> thunkHdrSize dflags+                  ThunkSelector{} -> thunkHdrSize dflags+                  BlackHole       -> thunkHdrSize dflags+                  IndStatic       -> thunkHdrSize dflags+                  _               -> fixedHdrSizeW dflags+        -- All thunks use thunkHdrSize, even if they are non-updatable.+        -- this is because we don't have separate closure types for+        -- updatable vs. non-updatable thunks, so the GC can't tell the+        -- difference.  If we ever have significant numbers of non-+        -- updatable thunks, it might be worth fixing this.++-- ---------------------------------------------------------------------------+-- Arrays++-- | The byte offset into the card table of the card for a given element+card :: DynFlags -> Int -> Int+card dflags i = i `shiftR` mUT_ARR_PTRS_CARD_BITS dflags++-- | Convert a number of elements to a number of cards, rounding up+cardRoundUp :: DynFlags -> Int -> Int+cardRoundUp dflags i =+  card dflags (i + ((1 `shiftL` mUT_ARR_PTRS_CARD_BITS dflags) - 1))++-- | The size of a card table, in bytes+cardTableSizeB :: DynFlags -> Int -> ByteOff+cardTableSizeB dflags elems = cardRoundUp dflags elems++-- | The size of a card table, in words+cardTableSizeW :: DynFlags -> Int -> WordOff+cardTableSizeW dflags elems =+  bytesToWordsRoundUp dflags (cardTableSizeB dflags elems)++-----------------------------------------------------------------------------+-- deriving the RTS closure type from an SMRep++#include "rts/storage/ClosureTypes.h"+#include "rts/storage/FunTypes.h"+-- Defines CONSTR, CONSTR_1_0 etc++-- | Derives the RTS closure type from an 'SMRep'+rtsClosureType :: SMRep -> Int+rtsClosureType rep+    = case rep of+      RTSRep ty _ -> ty++      -- See Note [static constructors]+      HeapRep _     1 0 Constr{} -> CONSTR_1_0+      HeapRep _     0 1 Constr{} -> CONSTR_0_1+      HeapRep _     2 0 Constr{} -> CONSTR_2_0+      HeapRep _     1 1 Constr{} -> CONSTR_1_1+      HeapRep _     0 2 Constr{} -> CONSTR_0_2+      HeapRep _     0 _ Constr{} -> CONSTR_NOCAF+           -- See Note [Static NoCaf constructors]+      HeapRep _     _ _ Constr{} -> CONSTR++      HeapRep False 1 0 Fun{} -> FUN_1_0+      HeapRep False 0 1 Fun{} -> FUN_0_1+      HeapRep False 2 0 Fun{} -> FUN_2_0+      HeapRep False 1 1 Fun{} -> FUN_1_1+      HeapRep False 0 2 Fun{} -> FUN_0_2+      HeapRep False _ _ Fun{} -> FUN++      HeapRep False 1 0 Thunk -> THUNK_1_0+      HeapRep False 0 1 Thunk -> THUNK_0_1+      HeapRep False 2 0 Thunk -> THUNK_2_0+      HeapRep False 1 1 Thunk -> THUNK_1_1+      HeapRep False 0 2 Thunk -> THUNK_0_2+      HeapRep False _ _ Thunk -> THUNK++      HeapRep False _ _ ThunkSelector{} ->  THUNK_SELECTOR++      HeapRep True _ _ Fun{}      -> FUN_STATIC+      HeapRep True _ _ Thunk      -> THUNK_STATIC+      HeapRep False _ _ BlackHole -> BLACKHOLE+      HeapRep False _ _ IndStatic -> IND_STATIC++      _ -> panic "rtsClosureType"++-- We export these ones+rET_SMALL, rET_BIG, aRG_GEN, aRG_GEN_BIG :: Int+rET_SMALL   = RET_SMALL+rET_BIG     = RET_BIG+aRG_GEN     = ARG_GEN+aRG_GEN_BIG = ARG_GEN_BIG++{-+Note [static constructors]+~~~~~~~~~~~~~~~~~~~~~~~~~~++We used to have a CONSTR_STATIC closure type, and each constructor had+two info tables: one with CONSTR (or CONSTR_1_0 etc.), and one with+CONSTR_STATIC.++This distinction was removed, because when copying a data structure+into a compact region, we must copy static constructors into the+compact region too.  If we didn't do this, we would need to track the+references from the compact region out to the static constructors,+because they might (indirectly) refer to CAFs.++Since static constructors will be copied to the heap, if we wanted to+use different info tables for static and dynamic constructors, we+would have to switch the info pointer when copying the constructor+into the compact region, which means we would need an extra field of+the static info table to point to the dynamic one.++However, since the distinction between static and dynamic closure+types is never actually needed (other than for assertions), we can+just drop the distinction and use the same info table for both.++The GC *does* need to distinguish between static and dynamic closures,+but it does this using the HEAP_ALLOCED() macro which checks whether+the address of the closure resides within the dynamic heap.+HEAP_ALLOCED() doesn't read the closure's info table.++Note [Static NoCaf constructors]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we know that a top-level binding 'x' is not Caffy (ie no CAFs are+reachable from 'x'), then a statically allocated constructor (Just x)+is also not Caffy, and the garbage collector need not follow its+argument fields.  Exploiting this would require two static info tables+for Just, for the two cases where the argument was Caffy or non-Caffy.++Currently we don't do this; instead we treat nullary constructors+as non-Caffy, and the others as potentially Caffy.+++************************************************************************+*                                                                      *+             Pretty printing of SMRep and friends+*                                                                      *+************************************************************************+-}++instance Outputable ClosureTypeInfo where+   ppr = pprTypeInfo++instance Outputable SMRep where+   ppr (HeapRep static ps nps tyinfo)+     = hang (header <+> lbrace) 2 (ppr tyinfo <+> rbrace)+     where+       header = text "HeapRep"+                <+> if static then text "static" else empty+                <+> pp_n "ptrs" ps <+> pp_n "nonptrs" nps+       pp_n :: String -> Int -> SDoc+       pp_n _ 0 = empty+       pp_n s n = int n <+> text s++   ppr (ArrayPtrsRep size _) = text "ArrayPtrsRep" <+> ppr size++   ppr (SmallArrayPtrsRep size) = text "SmallArrayPtrsRep" <+> ppr size++   ppr (ArrayWordsRep words) = text "ArrayWordsRep" <+> ppr words++   ppr (StackRep bs) = text "StackRep" <+> ppr bs++   ppr (RTSRep ty rep) = text "tag:" <> ppr ty <+> ppr rep++instance Outputable ArgDescr where+  ppr (ArgSpec n) = text "ArgSpec" <+> ppr n+  ppr (ArgGen ls) = text "ArgGen" <+> ppr ls++pprTypeInfo :: ClosureTypeInfo -> SDoc+pprTypeInfo (Constr tag descr)+  = text "Con" <+>+    braces (sep [ text "tag:" <+> ppr tag+                , text "descr:" <> text (show descr) ])++pprTypeInfo (Fun arity args)+  = text "Fun" <+>+    braces (sep [ text "arity:" <+> ppr arity+                , ptext (sLit ("fun_type:")) <+> ppr args ])++pprTypeInfo (ThunkSelector offset)+  = text "ThunkSel" <+> ppr offset++pprTypeInfo Thunk     = text "Thunk"+pprTypeInfo BlackHole = text "BlackHole"+pprTypeInfo IndStatic = text "IndStatic"

+ compiler/GHC/Runtime/Interpreter/Types.hs view

@@ -0,0 +1,63 @@+{-# LANGUAGE CPP #-}++-- | Types used by the runtime interpreter+module GHC.Runtime.Interpreter.Types+   ( Interp(..)+   , IServ(..)+   , IServInstance(..)+   , IServConfig(..)+   , IServState(..)+   )+where++import GhcPrelude++import GHCi.RemoteTypes+import GHCi.Message         ( Pipe )+import UniqFM+import Foreign++import Control.Concurrent+import System.Process   ( ProcessHandle, CreateProcess )++-- | Runtime interpreter+data Interp+   = ExternalInterp !IServ -- ^ External interpreter+#if defined(HAVE_INTERNAL_INTERPRETER)+   | InternalInterp        -- ^ Internal interpreter+#endif++-- | External interpreter+--+-- The external interpreter is spawned lazily (on first use) to avoid slowing+-- down sessions that don't require it. The contents of the MVar reflects the+-- state of the interpreter (running or not).+newtype IServ = IServ (MVar IServState)++-- | State of an external interpreter+data IServState+   = IServPending !IServConfig    -- ^ Not spawned yet+   | IServRunning !IServInstance  -- ^ Running++-- | Configuration needed to spawn an external interpreter+data IServConfig = IServConfig+  { iservConfProgram :: !String   -- ^ External program to run+  , iservConfOpts    :: ![String] -- ^ Command-line options+  , iservConfHook    :: !(Maybe (CreateProcess -> IO ProcessHandle)) -- ^ Hook+  , iservConfTrace   :: IO ()   -- ^ Trace action executed after spawn+  }++-- | External interpreter instance+data IServInstance = IServInstance+  { iservPipe              :: !Pipe+  , iservProcess           :: !ProcessHandle+  , iservLookupSymbolCache :: !(UniqFM (Ptr ()))+  , iservPendingFrees      :: ![HValueRef]+      -- ^ Values that need to be freed before the next command is sent.+      -- Threads can append values to this list asynchronously (by modifying the+      -- IServ state MVar).++  , iservConfig            :: !IServConfig+      -- ^ Config used to spawn the external interpreter+  }+

− compiler/GHC/Runtime/Layout.hs

@@ -1,563 +0,0 @@--- (c) The University of Glasgow 2006--- (c) The GRASP/AQUA Project, Glasgow University, 1992-1998------ Storage manager representation of closures--{-# LANGUAGE CPP,GeneralizedNewtypeDeriving #-}--module GHC.Runtime.Layout (-        -- * Words and bytes-        WordOff, ByteOff,-        wordsToBytes, bytesToWordsRoundUp,-        roundUpToWords, roundUpTo,--        StgWord, fromStgWord, toStgWord,-        StgHalfWord, fromStgHalfWord, toStgHalfWord,-        halfWordSize, halfWordSizeInBits,--        -- * Closure representation-        SMRep(..), -- CmmInfo sees the rep; no one else does-        IsStatic,-        ClosureTypeInfo(..), ArgDescr(..), Liveness,-        ConstrDescription,--        -- ** Construction-        mkHeapRep, blackHoleRep, indStaticRep, mkStackRep, mkRTSRep, arrPtrsRep,-        smallArrPtrsRep, arrWordsRep,--        -- ** Predicates-        isStaticRep, isConRep, isThunkRep, isFunRep, isStaticNoCafCon,-        isStackRep,--        -- ** Size-related things-        heapClosureSizeW,-        fixedHdrSizeW, arrWordsHdrSize, arrWordsHdrSizeW, arrPtrsHdrSize,-        arrPtrsHdrSizeW, profHdrSize, thunkHdrSize, nonHdrSize, nonHdrSizeW,-        smallArrPtrsHdrSize, smallArrPtrsHdrSizeW, hdrSize, hdrSizeW,-        fixedHdrSize,--        -- ** RTS closure types-        rtsClosureType, rET_SMALL, rET_BIG,-        aRG_GEN, aRG_GEN_BIG,--        -- ** Arrays-        card, cardRoundUp, cardTableSizeB, cardTableSizeW-    ) where--import GhcPrelude--import BasicTypes( ConTagZ )-import DynFlags-import Outputable-import GHC.Platform-import FastString--import Data.Word-import Data.Bits-import Data.ByteString (ByteString)--{--************************************************************************-*                                                                      *-                Words and bytes-*                                                                      *-************************************************************************--}---- | Word offset, or word count-type WordOff = Int---- | Byte offset, or byte count-type ByteOff = Int---- | 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 = 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--- a@ to allow for overloading.-wordsToBytes :: Num a => DynFlags -> a -> a-wordsToBytes dflags n = fromIntegral (wORD_SIZE dflags) * n-{-# SPECIALIZE wordsToBytes :: DynFlags -> Int -> Int #-}-{-# SPECIALIZE wordsToBytes :: DynFlags -> Word -> Word #-}-{-# SPECIALIZE wordsToBytes :: DynFlags -> Integer -> Integer #-}---- | First round the given byte count up to a multiple of the--- machine's word size and then convert the result to words.-bytesToWordsRoundUp :: DynFlags -> ByteOff -> WordOff-bytesToWordsRoundUp dflags n = (n + word_size - 1) `quot` word_size- where word_size = wORD_SIZE dflags--- StgWord is a type representing an StgWord on the target platform.--- A Word64 is large enough to hold a Word for either a 32bit or 64bit platform-newtype StgWord = StgWord Word64-    deriving (Eq, Bits)--fromStgWord :: StgWord -> Integer-fromStgWord (StgWord i) = toInteger i--toStgWord :: DynFlags -> Integer -> StgWord-toStgWord dflags i-    = case platformWordSize (targetPlatform dflags) of-      -- These conversions mean that things like toStgWord (-1)-      -- do the right thing-      PW4 -> StgWord (fromIntegral (fromInteger i :: Word32))-      PW8 -> StgWord (fromInteger i)--instance Outputable StgWord where-    ppr (StgWord i) = integer (toInteger i)-------- A Word32 is large enough to hold half a Word for either a 32bit or--- 64bit platform-newtype StgHalfWord = StgHalfWord Word32-    deriving Eq--fromStgHalfWord :: StgHalfWord -> Integer-fromStgHalfWord (StgHalfWord w) = toInteger w--toStgHalfWord :: DynFlags -> Integer -> StgHalfWord-toStgHalfWord dflags i-    = case platformWordSize (targetPlatform dflags) of-      -- These conversions mean that things like toStgHalfWord (-1)-      -- do the right thing-      PW4 -> StgHalfWord (fromIntegral (fromInteger i :: Word16))-      PW8 -> StgHalfWord (fromInteger i :: Word32)--instance Outputable StgHalfWord where-    ppr (StgHalfWord w) = integer (toInteger w)---- | Half word size in bytes-halfWordSize :: DynFlags -> ByteOff-halfWordSize dflags = platformWordSizeInBytes (targetPlatform dflags) `div` 2--halfWordSizeInBits :: DynFlags -> Int-halfWordSizeInBits dflags = platformWordSizeInBits (targetPlatform dflags) `div` 2--{--************************************************************************-*                                                                      *-\subsubsection[SMRep-datatype]{@SMRep@---storage manager representation}-*                                                                      *-************************************************************************--}---- | A description of the layout of a closure.  Corresponds directly--- to the closure types in includes/rts/storage/ClosureTypes.h.-data SMRep-  = HeapRep              -- GC routines consult sizes in info tbl-        IsStatic-        !WordOff         --  # ptr words-        !WordOff         --  # non-ptr words INCLUDING SLOP (see mkHeapRep below)-        ClosureTypeInfo  -- type-specific info--  | ArrayPtrsRep-        !WordOff        -- # ptr words-        !WordOff        -- # card table words--  | SmallArrayPtrsRep-        !WordOff        -- # ptr words--  | ArrayWordsRep-        !WordOff        -- # bytes expressed in words, rounded up--  | StackRep            -- Stack frame (RET_SMALL or RET_BIG)-        Liveness--  | RTSRep              -- The RTS needs to declare info tables with specific-        Int             -- type tags, so this form lets us override the default-        SMRep           -- tag for an SMRep.---- | True <=> This is a static closure.  Affects how we garbage-collect it.--- Static closure have an extra static link field at the end.--- Constructors do not have a static variant; see Note [static constructors]-type IsStatic = Bool---- From an SMRep you can get to the closure type defined in--- includes/rts/storage/ClosureTypes.h. Described by the function--- rtsClosureType below.--data ClosureTypeInfo-  = Constr        ConTagZ ConstrDescription-  | Fun           FunArity ArgDescr-  | Thunk-  | ThunkSelector SelectorOffset-  | BlackHole-  | IndStatic--type ConstrDescription = ByteString -- result of dataConIdentity-type FunArity          = Int-type SelectorOffset    = Int------------------------------ We represent liveness bitmaps as a Bitmap (whose internal--- representation really is a bitmap).  These are pinned onto case return--- vectors to indicate the state of the stack for the garbage collector.------ In the compiled program, liveness bitmaps that fit inside a single--- word (StgWord) are stored as a single word, while larger bitmaps are--- stored as a pointer to an array of words.--type Liveness = [Bool]   -- One Bool per word; True  <=> non-ptr or dead-                         --                    False <=> ptr------------------------------ An ArgDescr describes the argument pattern of a function--data ArgDescr-  = ArgSpec             -- Fits one of the standard patterns-        !Int            -- RTS type identifier ARG_P, ARG_N, ...--  | ArgGen              -- General case-        Liveness        -- Details about the arguments----------------------------------------------------------------------------------- Construction--mkHeapRep :: DynFlags -> IsStatic -> WordOff -> WordOff -> ClosureTypeInfo-          -> SMRep-mkHeapRep dflags is_static ptr_wds nonptr_wds cl_type_info-  = HeapRep is_static-            ptr_wds-            (nonptr_wds + slop_wds)-            cl_type_info-  where-     slop_wds-      | is_static = 0-      | otherwise = max 0 (minClosureSize dflags - (hdr_size + payload_size))--     hdr_size     = closureTypeHdrSize dflags cl_type_info-     payload_size = ptr_wds + nonptr_wds--mkRTSRep :: Int -> SMRep -> SMRep-mkRTSRep = RTSRep--mkStackRep :: [Bool] -> SMRep-mkStackRep liveness = StackRep liveness--blackHoleRep :: SMRep-blackHoleRep = HeapRep False 0 0 BlackHole--indStaticRep :: SMRep-indStaticRep = HeapRep True 1 0 IndStatic--arrPtrsRep :: DynFlags -> WordOff -> SMRep-arrPtrsRep dflags elems = ArrayPtrsRep elems (cardTableSizeW dflags elems)--smallArrPtrsRep :: WordOff -> SMRep-smallArrPtrsRep elems = SmallArrayPtrsRep elems--arrWordsRep :: DynFlags -> ByteOff -> SMRep-arrWordsRep dflags bytes = ArrayWordsRep (bytesToWordsRoundUp dflags bytes)---------------------------------------------------------------------------------- Predicates--isStaticRep :: SMRep -> IsStatic-isStaticRep (HeapRep is_static _ _ _) = is_static-isStaticRep (RTSRep _ rep)            = isStaticRep rep-isStaticRep _                         = False--isStackRep :: SMRep -> Bool-isStackRep StackRep{}     = True-isStackRep (RTSRep _ rep) = isStackRep rep-isStackRep _              = False--isConRep :: SMRep -> Bool-isConRep (HeapRep _ _ _ Constr{}) = True-isConRep _                        = False--isThunkRep :: SMRep -> Bool-isThunkRep (HeapRep _ _ _ Thunk)           = True-isThunkRep (HeapRep _ _ _ ThunkSelector{}) = True-isThunkRep (HeapRep _ _ _ BlackHole)       = True-isThunkRep (HeapRep _ _ _ IndStatic)       = True-isThunkRep _                               = False--isFunRep :: SMRep -> Bool-isFunRep (HeapRep _ _ _ Fun{}) = True-isFunRep _                     = False--isStaticNoCafCon :: SMRep -> Bool--- This should line up exactly with CONSTR_NOCAF below--- See Note [Static NoCaf constructors]-isStaticNoCafCon (HeapRep _ 0 _ Constr{}) = True-isStaticNoCafCon _                        = False----------------------------------------------------------------------------------- Size-related things--fixedHdrSize :: DynFlags -> ByteOff-fixedHdrSize dflags = wordsToBytes dflags (fixedHdrSizeW dflags)---- | Size of a closure header (StgHeader in includes/rts/storage/Closures.h)-fixedHdrSizeW :: DynFlags -> WordOff-fixedHdrSizeW dflags = sTD_HDR_SIZE dflags + profHdrSize dflags---- | Size of the profiling part of a closure header--- (StgProfHeader in includes/rts/storage/Closures.h)-profHdrSize  :: DynFlags -> WordOff-profHdrSize dflags- | gopt Opt_SccProfilingOn dflags = pROF_HDR_SIZE dflags- | otherwise                      = 0---- | The garbage collector requires that every closure is at least as---   big as this.-minClosureSize :: DynFlags -> WordOff-minClosureSize dflags = fixedHdrSizeW dflags + mIN_PAYLOAD_SIZE dflags--arrWordsHdrSize :: DynFlags -> ByteOff-arrWordsHdrSize dflags- = fixedHdrSize dflags + sIZEOF_StgArrBytes_NoHdr dflags--arrWordsHdrSizeW :: DynFlags -> WordOff-arrWordsHdrSizeW dflags =-    fixedHdrSizeW dflags +-    (sIZEOF_StgArrBytes_NoHdr dflags `quot` wORD_SIZE dflags)--arrPtrsHdrSize :: DynFlags -> ByteOff-arrPtrsHdrSize dflags- = fixedHdrSize dflags + sIZEOF_StgMutArrPtrs_NoHdr dflags--arrPtrsHdrSizeW :: DynFlags -> WordOff-arrPtrsHdrSizeW dflags =-    fixedHdrSizeW dflags +-    (sIZEOF_StgMutArrPtrs_NoHdr dflags `quot` wORD_SIZE dflags)--smallArrPtrsHdrSize :: DynFlags -> ByteOff-smallArrPtrsHdrSize dflags- = fixedHdrSize dflags + sIZEOF_StgSmallMutArrPtrs_NoHdr dflags--smallArrPtrsHdrSizeW :: DynFlags -> WordOff-smallArrPtrsHdrSizeW dflags =-    fixedHdrSizeW dflags +-    (sIZEOF_StgSmallMutArrPtrs_NoHdr dflags `quot` wORD_SIZE dflags)---- Thunks have an extra header word on SMP, so the update doesn't--- splat the payload.-thunkHdrSize :: DynFlags -> WordOff-thunkHdrSize dflags = fixedHdrSizeW dflags + smp_hdr-        where smp_hdr = sIZEOF_StgSMPThunkHeader dflags `quot` wORD_SIZE dflags--hdrSize :: DynFlags -> SMRep -> ByteOff-hdrSize dflags rep = wordsToBytes dflags (hdrSizeW dflags rep)--hdrSizeW :: DynFlags -> SMRep -> WordOff-hdrSizeW dflags (HeapRep _ _ _ ty)    = closureTypeHdrSize dflags ty-hdrSizeW dflags (ArrayPtrsRep _ _)    = arrPtrsHdrSizeW dflags-hdrSizeW dflags (SmallArrayPtrsRep _) = smallArrPtrsHdrSizeW dflags-hdrSizeW dflags (ArrayWordsRep _)     = arrWordsHdrSizeW dflags-hdrSizeW _ _                          = panic "SMRep.hdrSizeW"--nonHdrSize :: DynFlags -> SMRep -> ByteOff-nonHdrSize dflags rep = wordsToBytes dflags (nonHdrSizeW rep)--nonHdrSizeW :: SMRep -> WordOff-nonHdrSizeW (HeapRep _ p np _) = p + np-nonHdrSizeW (ArrayPtrsRep elems ct) = elems + ct-nonHdrSizeW (SmallArrayPtrsRep elems) = elems-nonHdrSizeW (ArrayWordsRep words) = words-nonHdrSizeW (StackRep bs)      = length bs-nonHdrSizeW (RTSRep _ rep)     = nonHdrSizeW rep---- | The total size of the closure, in words.-heapClosureSizeW :: DynFlags -> SMRep -> WordOff-heapClosureSizeW dflags (HeapRep _ p np ty)- = closureTypeHdrSize dflags ty + p + np-heapClosureSizeW dflags (ArrayPtrsRep elems ct)- = arrPtrsHdrSizeW dflags + elems + ct-heapClosureSizeW dflags (SmallArrayPtrsRep elems)- = smallArrPtrsHdrSizeW dflags + elems-heapClosureSizeW dflags (ArrayWordsRep words)- = arrWordsHdrSizeW dflags + words-heapClosureSizeW _ _ = panic "SMRep.heapClosureSize"--closureTypeHdrSize :: DynFlags -> ClosureTypeInfo -> WordOff-closureTypeHdrSize dflags ty = case ty of-                  Thunk           -> thunkHdrSize dflags-                  ThunkSelector{} -> thunkHdrSize dflags-                  BlackHole       -> thunkHdrSize dflags-                  IndStatic       -> thunkHdrSize dflags-                  _               -> fixedHdrSizeW dflags-        -- All thunks use thunkHdrSize, even if they are non-updatable.-        -- this is because we don't have separate closure types for-        -- updatable vs. non-updatable thunks, so the GC can't tell the-        -- difference.  If we ever have significant numbers of non--        -- updatable thunks, it might be worth fixing this.---- ------------------------------------------------------------------------------ Arrays---- | The byte offset into the card table of the card for a given element-card :: DynFlags -> Int -> Int-card dflags i = i `shiftR` mUT_ARR_PTRS_CARD_BITS dflags---- | Convert a number of elements to a number of cards, rounding up-cardRoundUp :: DynFlags -> Int -> Int-cardRoundUp dflags i =-  card dflags (i + ((1 `shiftL` mUT_ARR_PTRS_CARD_BITS dflags) - 1))---- | The size of a card table, in bytes-cardTableSizeB :: DynFlags -> Int -> ByteOff-cardTableSizeB dflags elems = cardRoundUp dflags elems---- | The size of a card table, in words-cardTableSizeW :: DynFlags -> Int -> WordOff-cardTableSizeW dflags elems =-  bytesToWordsRoundUp dflags (cardTableSizeB dflags elems)---------------------------------------------------------------------------------- deriving the RTS closure type from an SMRep--#include "rts/storage/ClosureTypes.h"-#include "rts/storage/FunTypes.h"--- Defines CONSTR, CONSTR_1_0 etc---- | Derives the RTS closure type from an 'SMRep'-rtsClosureType :: SMRep -> Int-rtsClosureType rep-    = case rep of-      RTSRep ty _ -> ty--      -- See Note [static constructors]-      HeapRep _     1 0 Constr{} -> CONSTR_1_0-      HeapRep _     0 1 Constr{} -> CONSTR_0_1-      HeapRep _     2 0 Constr{} -> CONSTR_2_0-      HeapRep _     1 1 Constr{} -> CONSTR_1_1-      HeapRep _     0 2 Constr{} -> CONSTR_0_2-      HeapRep _     0 _ Constr{} -> CONSTR_NOCAF-           -- See Note [Static NoCaf constructors]-      HeapRep _     _ _ Constr{} -> CONSTR--      HeapRep False 1 0 Fun{} -> FUN_1_0-      HeapRep False 0 1 Fun{} -> FUN_0_1-      HeapRep False 2 0 Fun{} -> FUN_2_0-      HeapRep False 1 1 Fun{} -> FUN_1_1-      HeapRep False 0 2 Fun{} -> FUN_0_2-      HeapRep False _ _ Fun{} -> FUN--      HeapRep False 1 0 Thunk -> THUNK_1_0-      HeapRep False 0 1 Thunk -> THUNK_0_1-      HeapRep False 2 0 Thunk -> THUNK_2_0-      HeapRep False 1 1 Thunk -> THUNK_1_1-      HeapRep False 0 2 Thunk -> THUNK_0_2-      HeapRep False _ _ Thunk -> THUNK--      HeapRep False _ _ ThunkSelector{} ->  THUNK_SELECTOR--      HeapRep True _ _ Fun{}      -> FUN_STATIC-      HeapRep True _ _ Thunk      -> THUNK_STATIC-      HeapRep False _ _ BlackHole -> BLACKHOLE-      HeapRep False _ _ IndStatic -> IND_STATIC--      _ -> panic "rtsClosureType"---- We export these ones-rET_SMALL, rET_BIG, aRG_GEN, aRG_GEN_BIG :: Int-rET_SMALL   = RET_SMALL-rET_BIG     = RET_BIG-aRG_GEN     = ARG_GEN-aRG_GEN_BIG = ARG_GEN_BIG--{--Note [static constructors]-~~~~~~~~~~~~~~~~~~~~~~~~~~--We used to have a CONSTR_STATIC closure type, and each constructor had-two info tables: one with CONSTR (or CONSTR_1_0 etc.), and one with-CONSTR_STATIC.--This distinction was removed, because when copying a data structure-into a compact region, we must copy static constructors into the-compact region too.  If we didn't do this, we would need to track the-references from the compact region out to the static constructors,-because they might (indirectly) refer to CAFs.--Since static constructors will be copied to the heap, if we wanted to-use different info tables for static and dynamic constructors, we-would have to switch the info pointer when copying the constructor-into the compact region, which means we would need an extra field of-the static info table to point to the dynamic one.--However, since the distinction between static and dynamic closure-types is never actually needed (other than for assertions), we can-just drop the distinction and use the same info table for both.--The GC *does* need to distinguish between static and dynamic closures,-but it does this using the HEAP_ALLOCED() macro which checks whether-the address of the closure resides within the dynamic heap.-HEAP_ALLOCED() doesn't read the closure's info table.--Note [Static NoCaf constructors]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we know that a top-level binding 'x' is not Caffy (ie no CAFs are-reachable from 'x'), then a statically allocated constructor (Just x)-is also not Caffy, and the garbage collector need not follow its-argument fields.  Exploiting this would require two static info tables-for Just, for the two cases where the argument was Caffy or non-Caffy.--Currently we don't do this; instead we treat nullary constructors-as non-Caffy, and the others as potentially Caffy.---************************************************************************-*                                                                      *-             Pretty printing of SMRep and friends-*                                                                      *-************************************************************************--}--instance Outputable ClosureTypeInfo where-   ppr = pprTypeInfo--instance Outputable SMRep where-   ppr (HeapRep static ps nps tyinfo)-     = hang (header <+> lbrace) 2 (ppr tyinfo <+> rbrace)-     where-       header = text "HeapRep"-                <+> if static then text "static" else empty-                <+> pp_n "ptrs" ps <+> pp_n "nonptrs" nps-       pp_n :: String -> Int -> SDoc-       pp_n _ 0 = empty-       pp_n s n = int n <+> text s--   ppr (ArrayPtrsRep size _) = text "ArrayPtrsRep" <+> ppr size--   ppr (SmallArrayPtrsRep size) = text "SmallArrayPtrsRep" <+> ppr size--   ppr (ArrayWordsRep words) = text "ArrayWordsRep" <+> ppr words--   ppr (StackRep bs) = text "StackRep" <+> ppr bs--   ppr (RTSRep ty rep) = text "tag:" <> ppr ty <+> ppr rep--instance Outputable ArgDescr where-  ppr (ArgSpec n) = text "ArgSpec" <+> ppr n-  ppr (ArgGen ls) = text "ArgGen" <+> ppr ls--pprTypeInfo :: ClosureTypeInfo -> SDoc-pprTypeInfo (Constr tag descr)-  = text "Con" <+>-    braces (sep [ text "tag:" <+> ppr tag-                , text "descr:" <> text (show descr) ])--pprTypeInfo (Fun arity args)-  = text "Fun" <+>-    braces (sep [ text "arity:" <+> ppr arity-                , ptext (sLit ("fun_type:")) <+> ppr args ])--pprTypeInfo (ThunkSelector offset)-  = text "ThunkSel" <+> ppr offset--pprTypeInfo Thunk     = text "Thunk"-pprTypeInfo BlackHole = text "BlackHole"-pprTypeInfo IndStatic = text "IndStatic"

+ compiler/GHC/Runtime/Linker/Types.hs view

@@ -0,0 +1,112 @@+-----------------------------------------------------------------------------+--+-- Types for the Dynamic Linker+--+-- (c) The University of Glasgow 2019+--+-----------------------------------------------------------------------------++module GHC.Runtime.Linker.Types (+      DynLinker(..),+      PersistentLinkerState(..),+      LinkerUnitId,+      Linkable(..),+      Unlinked(..),+      SptEntry(..)+    ) where++import GhcPrelude              ( FilePath, String, show )+import Data.Time               ( UTCTime )+import Data.Maybe              ( Maybe )+import Control.Concurrent.MVar ( MVar )+import Module                  ( InstalledUnitId, Module )+import GHC.ByteCode.Types           ( ItblEnv, CompiledByteCode )+import Outputable+import Var                     ( Id )+import GHC.Fingerprint.Type    ( Fingerprint )+import NameEnv                 ( NameEnv )+import Name                    ( Name )+import GHCi.RemoteTypes        ( ForeignHValue )++type ClosureEnv = NameEnv (Name, ForeignHValue)++newtype DynLinker =+  DynLinker { dl_mpls :: MVar (Maybe PersistentLinkerState) }++data PersistentLinkerState+  = PersistentLinkerState {++       -- Current global mapping from Names to their true values+       closure_env :: ClosureEnv,++       -- The current global mapping from RdrNames of DataCons to+       -- info table addresses.+       -- When a new Unlinked is linked into the running image, or an existing+       -- module in the image is replaced, the itbl_env must be updated+       -- appropriately.+       itbl_env    :: !ItblEnv,++       -- The currently loaded interpreted modules (home package)+       bcos_loaded :: ![Linkable],++       -- And the currently-loaded compiled modules (home package)+       objs_loaded :: ![Linkable],++       -- The currently-loaded packages; always object code+       -- Held, as usual, in dependency order; though I am not sure if+       -- that is really important+       pkgs_loaded :: ![LinkerUnitId],++       -- we need to remember the name of previous temporary DLL/.so+       -- libraries so we can link them (see #10322)+       temp_sos :: ![(FilePath, String)] }++-- TODO: Make this type more precise+type LinkerUnitId = InstalledUnitId++-- | Information we can use to dynamically link modules into the compiler+data Linkable = LM {+  linkableTime     :: UTCTime,          -- ^ Time at which this linkable was built+                                        -- (i.e. when the bytecodes were produced,+                                        --       or the mod date on the files)+  linkableModule   :: Module,           -- ^ The linkable module itself+  linkableUnlinked :: [Unlinked]+    -- ^ Those files and chunks of code we have yet to link.+    --+    -- INVARIANT: A valid linkable always has at least one 'Unlinked' item.+    -- If this list is empty, the Linkable represents a fake linkable, which+    -- is generated in HscNothing mode to avoid recompiling modules.+    --+    -- ToDo: Do items get removed from this list when they get linked?+ }++instance Outputable Linkable where+  ppr (LM when_made mod unlinkeds)+     = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)+       $$ nest 3 (ppr unlinkeds)++-- | Objects which have yet to be linked by the compiler+data Unlinked+  = DotO FilePath      -- ^ An object file (.o)+  | DotA FilePath      -- ^ Static archive file (.a)+  | DotDLL FilePath    -- ^ Dynamically linked library file (.so, .dll, .dylib)+  | BCOs CompiledByteCode+         [SptEntry]    -- ^ A byte-code object, lives only in memory. Also+                       -- carries some static pointer table entries which+                       -- should be loaded along with the BCOs.+                       -- See Note [Grant plan for static forms] in+                       -- StaticPtrTable.++instance Outputable Unlinked where+  ppr (DotO path)   = text "DotO" <+> text path+  ppr (DotA path)   = text "DotA" <+> text path+  ppr (DotDLL path) = text "DotDLL" <+> text path+  ppr (BCOs bcos spt) = text "BCOs" <+> ppr bcos <+> ppr spt++-- | An entry to be inserted into a module's static pointer table.+-- See Note [Grand plan for static forms] in StaticPtrTable.+data SptEntry = SptEntry Id Fingerprint++instance Outputable SptEntry where+  ppr (SptEntry id fpr) = ppr id <> colon <+> ppr fpr+

compiler/GHC/Stg/Syntax.hs view

@@ -5,7 +5,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  This data type represents programs just before code generation (conversion to-@Cmm@): basically, what we have is a stylised form of @CoreSyntax@, the style+@Cmm@): basically, what we have is a stylised form of Core syntax, the style being one that happens to be ideally suited to spineless tagless code generation. -}@@ -18,6 +18,7 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE LambdaCase #-}  module GHC.Stg.Syntax (         StgArg(..),@@ -48,11 +49,12 @@         StgOp(..),          -- utils-        topStgBindHasCafRefs, stgArgHasCafRefs, stgRhsArity,+        stgRhsArity,         isDllConApp,         stgArgType,         stripStgTicksTop, stripStgTicksTopE,         stgCaseBndrInScope,+        bindersOf, bindersOfTop, bindersOfTopBinds,          pprStgBinding, pprGenStgTopBindings, pprStgTopBindings     ) where@@ -61,23 +63,22 @@  import GhcPrelude -import CoreSyn     ( AltCon, Tickish )+import GHC.Core     ( AltCon, Tickish ) import CostCentre  ( CostCentreStack ) import Data.ByteString ( ByteString ) import Data.Data   ( Data ) import Data.List   ( intersperse ) import DataCon-import DynFlags+import GHC.Driver.Session import ForeignCall ( ForeignCall ) import Id-import IdInfo      ( mayHaveCafRefs ) import VarSet import Literal     ( Literal, literalType ) import Module      ( Module ) import Outputable-import Packages    ( isDllName )+import GHC.Driver.Packages    ( isDllName ) import GHC.Platform-import PprCore     ( {- instances -} )+import GHC.Core.Ppr( {- instances -} ) import PrimOp      ( PrimOp, PrimCall ) import TyCon       ( PrimRep(..), TyCon ) import Type        ( Type )@@ -95,12 +96,12 @@  As usual, expressions are interesting; other things are boring. Here are the boring things (except note the @GenStgRhs@), parameterised with respect to-binder and occurrence information (just as in @CoreSyn@):+binder and occurrence information (just as in @GHC.Core@): -}  -- | A top-level binding. data GenStgTopBinding pass--- See Note [CoreSyn top-level string literals]+-- See Note [Core top-level string literals]   = StgTopLifted (GenStgBinding pass)   | StgTopStringLit Id ByteString @@ -475,82 +476,6 @@   -- The arity never includes type parameters, but they should have gone by now stgRhsArity (StgRhsCon _ _ _) = 0 --- Note [CAF consistency]--- ~~~~~~~~~~~~~~~~~~~~~~------ `topStgBindHasCafRefs` is only used by an assert (`consistentCafInfo` in--- `CoreToStg`) to make sure CAF-ness predicted by `GHC.Iface.Tidy` is consistent with--- reality.------ Specifically, if the RHS mentions any Id that itself is marked--- `MayHaveCafRefs`; or if the binding is a top-level updateable thunk; then the--- `Id` for the binding should be marked `MayHaveCafRefs`. The potential trouble--- is that `GHC.Iface.Tidy` computed the CAF info on the `Id` but some transformations--- have taken place since then.--topStgBindHasCafRefs :: GenStgTopBinding pass -> Bool-topStgBindHasCafRefs (StgTopLifted (StgNonRec _ rhs))-  = topRhsHasCafRefs rhs-topStgBindHasCafRefs (StgTopLifted (StgRec binds))-  = any topRhsHasCafRefs (map snd binds)-topStgBindHasCafRefs StgTopStringLit{}-  = False--topRhsHasCafRefs :: GenStgRhs pass -> Bool-topRhsHasCafRefs (StgRhsClosure _ _ upd _ body)-  = -- See Note [CAF consistency]-    isUpdatable upd || exprHasCafRefs body-topRhsHasCafRefs (StgRhsCon _ _ args)-  = any stgArgHasCafRefs args--exprHasCafRefs :: GenStgExpr pass -> Bool-exprHasCafRefs (StgApp f args)-  = stgIdHasCafRefs f || any stgArgHasCafRefs args-exprHasCafRefs StgLit{}-  = False-exprHasCafRefs (StgConApp _ args _)-  = any stgArgHasCafRefs args-exprHasCafRefs (StgOpApp _ args _)-  = any stgArgHasCafRefs args-exprHasCafRefs (StgLam _ body)-  = exprHasCafRefs body-exprHasCafRefs (StgCase scrt _ _ alts)-  = exprHasCafRefs scrt || any altHasCafRefs alts-exprHasCafRefs (StgLet _ bind body)-  = bindHasCafRefs bind || exprHasCafRefs body-exprHasCafRefs (StgLetNoEscape _ bind body)-  = bindHasCafRefs bind || exprHasCafRefs body-exprHasCafRefs (StgTick _ expr)-  = exprHasCafRefs expr--bindHasCafRefs :: GenStgBinding pass -> Bool-bindHasCafRefs (StgNonRec _ rhs)-  = rhsHasCafRefs rhs-bindHasCafRefs (StgRec binds)-  = any rhsHasCafRefs (map snd binds)--rhsHasCafRefs :: GenStgRhs pass -> Bool-rhsHasCafRefs (StgRhsClosure _ _ _ _ body)-  = exprHasCafRefs body-rhsHasCafRefs (StgRhsCon _ _ args)-  = any stgArgHasCafRefs args--altHasCafRefs :: GenStgAlt pass -> Bool-altHasCafRefs (_, _, rhs) = exprHasCafRefs rhs--stgArgHasCafRefs :: StgArg -> Bool-stgArgHasCafRefs (StgVarArg id)-  = stgIdHasCafRefs id-stgArgHasCafRefs _-  = False--stgIdHasCafRefs :: Id -> Bool-stgIdHasCafRefs id =-  -- We are looking for occurrences of an Id that is bound at top level, and may-  -- have CAF refs. At this point (after GHC.Iface.Tidy) top-level Ids (whether-  -- imported or defined in this module) are GlobalIds, so the test is easy.-  isGlobalId id && mayHaveCafRefs (idCafInfo id)- {- ************************************************************************ *                                                                      *@@ -558,7 +483,7 @@ *                                                                      * ************************************************************************ -Very like in @CoreSyntax@ (except no type-world stuff).+Very like in Core syntax (except no type-world stuff).  The type constructor is guaranteed not to be abstract; that is, we can see its representation. This is important because the code generator uses it to@@ -612,7 +537,7 @@  {- Many passes apply a substitution, and it's very handy to have type    synonyms to remind us whether or not the substitution has been applied.-   See CoreSyn for precedence in Core land+   See GHC.Core for precedence in Core land -}  type InStgTopBinding  = StgTopBinding@@ -682,6 +607,25 @@ {- ************************************************************************ *                                                                      *+Utilities+*                                                                      *+************************************************************************+-}++bindersOf :: BinderP a ~ Id => GenStgBinding a -> [Id]+bindersOf (StgNonRec binder _) = [binder]+bindersOf (StgRec pairs)       = [binder | (binder, _) <- pairs]++bindersOfTop :: BinderP a ~ Id => GenStgTopBinding a -> [Id]+bindersOfTop (StgTopLifted bind) = bindersOf bind+bindersOfTop (StgTopStringLit binder _) = [binder]++bindersOfTopBinds :: BinderP a ~ Id => [GenStgTopBinding a] -> [Id]+bindersOfTopBinds = foldr ((++) . bindersOfTop) []++{-+************************************************************************+*                                                                      * Pretty-printing *                                                                      * ************************************************************************@@ -813,10 +757,9 @@                 2 (ppr expr)]  pprStgExpr (StgTick tickish expr)-  = sdocWithDynFlags $ \dflags ->-    if gopt Opt_SuppressTicks dflags-    then pprStgExpr expr-    else sep [ ppr tickish, pprStgExpr expr ]+  = sdocOption sdocSuppressTicks $ \case+      True  -> pprStgExpr expr+      False -> sep [ ppr tickish, pprStgExpr expr ]   -- Don't indent for a single case alternative.@@ -861,8 +804,7 @@ pprStgRhs (StgRhsClosure ext cc upd_flag args body)   = sdocWithDynFlags $ \dflags ->     hang (hsep [if gopt Opt_SccProfilingOn dflags then ppr cc else empty,-                if not $ gopt Opt_SuppressStgExts dflags-                  then ppr ext else empty,+                ppUnlessOption sdocSuppressStgExts (ppr ext),                 char '\\' <> ppr upd_flag, brackets (interppSP args)])          4 (ppr body)

− compiler/backpack/BkpSyn.hs

@@ -1,83 +0,0 @@--- | This is the syntax for bkp files which are parsed in 'ghc --backpack'--- mode.  This syntax is used purely for testing purposes.--module BkpSyn (-    -- * Backpack abstract syntax-    HsUnitId(..),-    LHsUnitId,-    HsModuleSubst,-    LHsModuleSubst,-    HsModuleId(..),-    LHsModuleId,-    HsComponentId(..),-    LHsUnit, HsUnit(..),-    LHsUnitDecl, HsUnitDecl(..),-    IncludeDecl(..),-    LRenaming, Renaming(..),-    ) where--import GhcPrelude--import DriverPhases-import GHC.Hs-import SrcLoc-import Outputable-import Module-import UnitInfo--{--************************************************************************-*                                                                      *-                        User syntax-*                                                                      *-************************************************************************--}--data HsComponentId = HsComponentId {-    hsPackageName :: PackageName,-    hsComponentId :: ComponentId-    }--instance Outputable HsComponentId where-    ppr (HsComponentId _pn cid) = ppr cid -- todo debug with pn--data HsUnitId n = HsUnitId (Located n) [LHsModuleSubst n]-type LHsUnitId n = Located (HsUnitId n)--type HsModuleSubst n = (Located ModuleName, LHsModuleId n)-type LHsModuleSubst n = Located (HsModuleSubst n)--data HsModuleId n = HsModuleVar (Located ModuleName)-                  | HsModuleId (LHsUnitId n) (Located ModuleName)-type LHsModuleId n = Located (HsModuleId n)---- | Top level @unit@ declaration in a Backpack file.-data HsUnit n = HsUnit {-        hsunitName :: Located n,-        hsunitBody :: [LHsUnitDecl n]-    }-type LHsUnit n = Located (HsUnit n)---- | A declaration in a package, e.g. a module or signature definition,--- or an include.-data HsUnitDecl n-    = DeclD   HscSource (Located ModuleName) (Maybe (Located HsModule))-    | IncludeD   (IncludeDecl n)-type LHsUnitDecl n = Located (HsUnitDecl n)---- | An include of another unit-data IncludeDecl n = IncludeDecl {-        idUnitId :: LHsUnitId n,-        idModRenaming :: Maybe [ LRenaming ],-        -- | Is this a @dependency signature@ include?  If so,-        -- we don't compile this include when we instantiate this-        -- unit (as there should not be any modules brought into-        -- scope.)-        idSignatureInclude :: Bool-    }---- | Rename a module from one name to another.  The identity renaming--- means that the module should be brought into scope.-data Renaming = Renaming { renameFrom :: Located ModuleName-                         , renameTo :: Maybe (Located ModuleName) }-type LRenaming = Located Renaming

compiler/basicTypes/BasicTypes.hs view

@@ -154,7 +154,7 @@ -- "real work". So: --  fib 100     has arity 0 --  \x -> fib x has arity 1--- See also Note [Definition of arity] in CoreArity+-- See also Note [Definition of arity] in GHC.Core.Arity type Arity = Int  -- | Representation Arity@@ -325,6 +325,9 @@ isPromoted IsPromoted  = True isPromoted NotPromoted = False +instance Outputable PromotionFlag where+  ppr NotPromoted = text "NotPromoted"+  ppr IsPromoted  = text "IsPromoted"  {- ************************************************************************@@ -1327,7 +1330,7 @@  If inl_inline = Inline or Inlineable, then the Id should have an InlineRule unfolding. -If you want to know where InlinePragmas take effect: Look in DsBinds.makeCorePair+If you want to know where InlinePragmas take effect: Look in GHC.HsToCore.Binds.makeCorePair  Note [inl_inline and inl_act] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1374,13 +1377,13 @@     - The occurrence analyser (OccAnal) and simplifier (Simplify) treat       CONLIKE thing like constructors, by ANF-ing them -    - New function CoreUtils.exprIsExpandable is like exprIsCheap, but+    - New function GHC.Core.Utils.exprIsExpandable is like exprIsCheap, but       additionally spots applications of CONLIKE functions      - A CoreUnfolding has a field that caches exprIsExpandable      - The rule matcher consults this field.  See-      Note [Expanding variables] in Rules.hs.+      Note [Expanding variables] in GHC.Core.Rules. -}  isConLike :: RuleMatchInfo -> Bool@@ -1526,7 +1529,7 @@ {- Note [Competing activations] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sometimes a RULE and an inlining may compete, or two RULES.-See Note [Rules and inlining/other rules] in Desugar.+See Note [Rules and inlining/other rules] in GHC.HsToCore.  We say that act1 "competes with" act2 iff    act1 is active in the phase when act2 *becomes* active@@ -1615,7 +1618,7 @@                                    fl_value = fromInteger i }  -- Comparison operations are needed when grouping literals--- for compiling pattern-matching (module MatchLit)+-- for compiling pattern-matching (module GHC.HsToCore.Match.Literal)  instance Eq IntegralLit where   (==) = (==) `on` il_value

+ compiler/basicTypes/Cpr.hs view

@@ -0,0 +1,163 @@+{-# LANGUAGE GeneralisedNewtypeDeriving #-}+-- | Types for the Constructed Product Result lattice. "CprAnal" and "WwLib"+-- are its primary customers via 'idCprInfo'.+module Cpr (+    CprResult, topCpr, botCpr, conCpr, asConCpr,+    CprType (..), topCprType, botCprType, conCprType,+    lubCprType, applyCprTy, abstractCprTy, ensureCprTyArity, trimCprTy,+    CprSig (..), topCprSig, mkCprSigForArity, mkCprSig, seqCprSig+  ) where++import GhcPrelude++import BasicTypes+import Outputable+import Binary++--+-- * CprResult+--++-- | The constructed product result lattice.+--+-- @+--                    NoCPR+--                      |+--                 ConCPR ConTag+--                      |+--                    BotCPR+-- @+data CprResult = NoCPR          -- ^ Top of the lattice+               | ConCPR !ConTag -- ^ Returns a constructor from a data type+               | BotCPR         -- ^ Bottom of the lattice+               deriving( Eq, Show )++lubCpr :: CprResult -> CprResult -> CprResult+lubCpr (ConCPR t1) (ConCPR t2)+  | t1 == t2               = ConCPR t1+lubCpr BotCPR      cpr     = cpr+lubCpr cpr         BotCPR  = cpr+lubCpr _           _       = NoCPR++topCpr :: CprResult+topCpr = NoCPR++botCpr :: CprResult+botCpr = BotCPR++conCpr :: ConTag -> CprResult+conCpr = ConCPR++trimCpr :: CprResult -> CprResult+trimCpr ConCPR{} = NoCPR+trimCpr cpr      = cpr++asConCpr :: CprResult -> Maybe ConTag+asConCpr (ConCPR t)  = Just t+asConCpr NoCPR       = Nothing+asConCpr BotCPR      = Nothing++--+-- * CprType+--++-- | The abstract domain \(A_t\) from the original 'CPR for Haskell' paper.+data CprType+  = CprType+  { ct_arty :: !Arity     -- ^ Number of value arguments the denoted expression+                          --   eats before returning the 'ct_cpr'+  , ct_cpr  :: !CprResult -- ^ 'CprResult' eventually unleashed when applied to+                          --   'ct_arty' arguments+  }++instance Eq CprType where+  a == b =  ct_cpr a == ct_cpr b+         && (ct_arty a == ct_arty b || ct_cpr a == topCpr)++topCprType :: CprType+topCprType = CprType 0 topCpr++botCprType :: CprType+botCprType = CprType 0 botCpr -- TODO: Figure out if arity 0 does what we want... Yes it does: arity zero means we may unleash it under any number of incoming arguments++conCprType :: ConTag -> CprType+conCprType con_tag = CprType 0 (conCpr con_tag)++lubCprType :: CprType -> CprType -> CprType+lubCprType ty1@(CprType n1 cpr1) ty2@(CprType n2 cpr2)+  -- The arity of bottom CPR types can be extended arbitrarily.+  | cpr1 == botCpr && n1 <= n2 = ty2+  | cpr2 == botCpr && n2 <= n1 = ty1+  -- There might be non-bottom CPR types with mismatching arities.+  -- Consider test DmdAnalGADTs. We want to return top in these cases.+  | n1 == n2                   = CprType n1 (lubCpr cpr1 cpr2)+  | otherwise                  = topCprType++applyCprTy :: CprType -> CprType+applyCprTy (CprType n res)+  | n > 0         = CprType (n-1) res+  | res == botCpr = botCprType+  | otherwise     = topCprType++abstractCprTy :: CprType -> CprType+abstractCprTy (CprType n res)+  | res == topCpr = topCprType+  | otherwise     = CprType (n+1) res++ensureCprTyArity :: Arity -> CprType -> CprType+ensureCprTyArity n ty@(CprType m _)+  | n == m    = ty+  | otherwise = topCprType++trimCprTy :: CprType -> CprType+trimCprTy (CprType arty res) = CprType arty (trimCpr res)++-- | The arity of the wrapped 'CprType' is the arity at which it is safe+-- to unleash. See Note [Understanding DmdType and StrictSig] in Demand+newtype CprSig = CprSig { getCprSig :: CprType }+  deriving (Eq, Binary)++-- | Turns a 'CprType' computed for the particular 'Arity' into a 'CprSig'+-- unleashable at that arity. See Note [Understanding DmdType and StrictSig] in+-- Demand+mkCprSigForArity :: Arity -> CprType -> CprSig+mkCprSigForArity arty ty = CprSig (ensureCprTyArity arty ty)++topCprSig :: CprSig+topCprSig = CprSig topCprType++mkCprSig :: Arity -> CprResult -> CprSig+mkCprSig arty cpr = CprSig (CprType arty cpr)++seqCprSig :: CprSig -> ()+seqCprSig sig = sig `seq` ()++instance Outputable CprResult where+  ppr NoCPR        = empty+  ppr (ConCPR n)   = char 'm' <> int n+  ppr BotCPR       = char 'b'++instance Outputable CprType where+  ppr (CprType arty res) = ppr arty <> ppr res++-- | Only print the CPR result+instance Outputable CprSig where+  ppr (CprSig ty) = ppr (ct_cpr ty)++instance Binary CprResult where+  put_ bh (ConCPR n)   = do { putByte bh 0; put_ bh n }+  put_ bh NoCPR        = putByte bh 1+  put_ bh BotCPR       = putByte bh 2++  get  bh = do+          h <- getByte bh+          case h of+            0 -> do { n <- get bh; return (ConCPR n) }+            1 -> return NoCPR+            _ -> return BotCPR++instance Binary CprType where+  put_ bh (CprType arty cpr) = do+    put_ bh arty+    put_ bh cpr+  get  bh = CprType <$> get bh <*> get bh

compiler/basicTypes/DataCon.hs view

@@ -24,7 +24,7 @@         FieldLbl(..), FieldLabel, FieldLabelString,          -- ** Type construction-        mkDataCon, buildAlgTyCon, buildSynTyCon, fIRST_TAG,+        mkDataCon, fIRST_TAG,          -- ** Type deconstruction         dataConRepType, dataConInstSig, dataConFullSig,@@ -65,7 +65,6 @@  import {-# SOURCE #-} MkId( DataConBoxer ) import Type-import ForeignCall ( CType ) import Coercion import Unify import TyCon@@ -75,7 +74,6 @@ import PrelNames import Predicate import Var-import VarSet( emptyVarSet ) import Outputable import Util import BasicTypes@@ -463,7 +461,7 @@         -- It's convenient to apply the rep-type of MkT to 't', to get         --      forall x y. (t~(x,y), x~y, Ord x) => x -> y -> T t         -- and use that to check the pattern.  Mind you, this is really only-        -- used in CoreLint.+        -- used in GHC.Core.Lint.           dcInfix :: Bool,        -- True <=> declared infix@@ -1310,7 +1308,8 @@                         -- equality constraints or dicts         -> [Type] -- For vanilla datacons, it's all quite straightforward--- But for the call in MatchCon, we really do want just the value args+-- But for the call in GHC.HsToCore.Match.Constructor, we really do want just+-- the value args dataConInstOrigArgTys dc@(MkData {dcOrigArgTys = arg_tys,                                   dcUnivTyVars = univ_tvs,                                   dcExTyCoVars = ex_tvs}) inst_tys@@ -1380,6 +1379,10 @@ --                  scrutinee of type (T tys) --                  where T is the dcRepTyCon for the data con dataConCannotMatch tys con+  -- See (U6) in Note [Implementing unsafeCoerce]+  -- in base:Unsafe.Coerce+  | dataConName con == unsafeReflDataConName+                      = False   | null inst_theta   = False   -- Common   | all isTyVarTy tys = False   -- Also common   | otherwise         = typesCantMatch (concatMap predEqs inst_theta)@@ -1463,38 +1466,3 @@   | otherwise   = Nothing -{--************************************************************************-*                                                                      *-              Building an algebraic data type-*                                                                      *-************************************************************************--buildAlgTyCon is here because it is called from TysWiredIn, which can-depend on this module, but not on BuildTyCl.--}--buildAlgTyCon :: Name-              -> [TyVar]               -- ^ Kind variables and type variables-              -> [Role]-              -> Maybe CType-              -> ThetaType             -- ^ Stupid theta-              -> AlgTyConRhs-              -> Bool                  -- ^ True <=> was declared in GADT syntax-              -> AlgTyConFlav-              -> TyCon--buildAlgTyCon tc_name ktvs roles cType stupid_theta rhs-              gadt_syn parent-  = mkAlgTyCon tc_name binders liftedTypeKind roles cType stupid_theta-               rhs parent gadt_syn-  where-    binders = mkTyConBindersPreferAnon ktvs emptyVarSet--buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind   -- ^ /result/ kind-              -> [Role] -> KnotTied Type -> TyCon-buildSynTyCon name binders res_kind roles rhs-  = mkSynonymTyCon name binders res_kind roles rhs is_tau is_fam_free-  where-    is_tau      = isTauTy rhs-    is_fam_free = isFamFreeTy rhs

compiler/basicTypes/Demand.hs view

@@ -29,12 +29,8 @@         DmdEnv, emptyDmdEnv,         peelFV, findIdDemand, -        DmdResult, CPRResult,-        isBotRes, isTopRes,-        topRes, botRes, cprProdRes,-        vanillaCprProdRes, cprSumRes,+        Divergence(..), lubDivergence, isBotDiv, isTopDiv, topDiv, botDiv,         appIsBottom, isBottomingSig, pprIfaceStrictSig,-        trimCPRInfo, returnsCPR_maybe,         StrictSig(..), mkStrictSigForArity, mkClosedStrictSig,         nopSig, botSig, cprProdSig,         isTopSig, hasDemandEnvSig,@@ -64,7 +60,7 @@  import GhcPrelude -import DynFlags+import GHC.Driver.Session import Outputable import Var ( Var ) import VarEnv@@ -146,9 +142,9 @@ Ben opened #11222. Simon made the demand analyser "understand catch" in 9915b656 (Jan 16) by adding a new 'catchArgDmd', which basically said to call its argument strictly, but also swallow any thrown exceptions in-'postProcessDmdResult'. This was realized by extending the 'Str' constructor of+'postProcessDivergence'. This was realized by extending the 'Str' constructor of 'ArgStr' with a 'ExnStr' field, indicating that it catches the exception, and-adding a 'ThrowsExn' constructor to the 'Termination' lattice as an element+adding a 'ThrowsExn' constructor to the 'Divergence' lattice as an element between 'Dunno' and 'Diverges'. Then along came #11555 and finally #13330, so we had to revert to 'lazyApply1Dmd' again in 701256df88c (Mar 17). @@ -900,85 +896,41 @@ {- ************************************************************************ *                                                                      *-                   Demand results+                   Termination *                                                                      * ************************************************************************ --DmdResult:     Dunno CPRResult+Divergence:     Dunno                /           Diverges --CPRResult:         NoCPR-                   /    \-            RetProd    RetSum ConTag---Product constructors return (Dunno (RetProd rs)) In a fixpoint iteration, start from Diverges-We have lubs, but not glbs; but that is ok. -} ---------------------------------------------------------------------------- Constructed Product Result---------------------------------------------------------------------------data Termination r+data Divergence   = Diverges    -- Definitely diverges-  | Dunno r     -- Might diverge or converge+  | Dunno       -- Might diverge or converge   deriving( Eq, Show ) --- At this point, Termination is just the 'Lifted' lattice over 'r'--- (https://hackage.haskell.org/package/lattices/docs/Algebra-Lattice-Lifted.html)--type DmdResult = Termination CPRResult--data CPRResult = NoCPR          -- Top of the lattice-               | RetProd        -- Returns a constructor from a product type-               | RetSum ConTag  -- Returns a constructor from a data type-               deriving( Eq, Show )--lubCPR :: CPRResult -> CPRResult -> CPRResult-lubCPR (RetSum t1) (RetSum t2)-  | t1 == t2                       = RetSum t1-lubCPR RetProd     RetProd     = RetProd-lubCPR _ _                     = NoCPR--lubDmdResult :: DmdResult -> DmdResult -> DmdResult-lubDmdResult Diverges       r              = r-lubDmdResult r              Diverges       = r-lubDmdResult (Dunno c1)     (Dunno c2)     = Dunno (c1 `lubCPR` c2)+lubDivergence :: Divergence -> Divergence ->Divergence+lubDivergence Diverges r        = r+lubDivergence r        Diverges = r+lubDivergence Dunno    Dunno    = Dunno -- This needs to commute with defaultDmd, i.e.--- defaultDmd (r1 `lubDmdResult` r2) = defaultDmd r1 `lubDmd` defaultDmd r2+-- defaultDmd (r1 `lubDivergence` r2) = defaultDmd r1 `lubDmd` defaultDmd r2 -- (See Note [Default demand on free variables] for why) -bothDmdResult :: DmdResult -> Termination () -> DmdResult--- See Note [Asymmetry of 'both' for DmdType and DmdResult]-bothDmdResult _ Diverges   = Diverges-bothDmdResult r (Dunno {}) = r+bothDivergence :: Divergence -> Divergence -> Divergence+-- See Note [Asymmetry of 'both' for DmdType and Divergence]+bothDivergence _ Diverges = Diverges+bothDivergence r Dunno    = r -- This needs to commute with defaultDmd, i.e.--- defaultDmd (r1 `bothDmdResult` r2) = defaultDmd r1 `bothDmd` defaultDmd r2+-- defaultDmd (r1 `bothDivergence` r2) = defaultDmd r1 `bothDmd` defaultDmd r2 -- (See Note [Default demand on free variables] for why) -instance Outputable r => Outputable (Termination r) where+instance Outputable Divergence where   ppr Diverges      = char 'b'-  ppr (Dunno c)     = ppr c--instance Outputable CPRResult where-  ppr NoCPR        = empty-  ppr (RetSum n)   = char 'm' <> int n-  ppr RetProd      = char 'm'--seqDmdResult :: DmdResult -> ()-seqDmdResult Diverges  = ()-seqDmdResult (Dunno c) = seqCPRResult c--seqCPRResult :: CPRResult -> ()-seqCPRResult NoCPR        = ()-seqCPRResult (RetSum n)   = n `seq` ()-seqCPRResult RetProd      = ()-+  ppr Dunno         = empty  ------------------------------------------------------------------------ -- Combined demand result                                             --@@ -986,64 +938,33 @@  -- [cprRes] lets us switch off CPR analysis -- by making sure that everything uses TopRes-topRes, botRes :: DmdResult-topRes = Dunno NoCPR-botRes = Diverges--cprSumRes :: ConTag -> DmdResult-cprSumRes tag = Dunno $ RetSum tag--cprProdRes :: [DmdType] -> DmdResult-cprProdRes _arg_tys = Dunno $ RetProd--vanillaCprProdRes :: Arity -> DmdResult-vanillaCprProdRes _arity = Dunno $ RetProd+topDiv, botDiv :: Divergence+topDiv = Dunno+botDiv = Diverges -isTopRes :: DmdResult -> Bool-isTopRes (Dunno NoCPR) = True-isTopRes _             = False+isTopDiv :: Divergence -> Bool+isTopDiv Dunno = True+isTopDiv _     = False  -- | True if the result diverges or throws an exception-isBotRes :: DmdResult -> Bool-isBotRes Diverges   = True-isBotRes (Dunno {}) = False--trimCPRInfo :: Bool -> Bool -> DmdResult -> DmdResult-trimCPRInfo trim_all trim_sums res-  = trimR res-  where-    trimR (Dunno c) = Dunno (trimC c)-    trimR res       = res--    trimC (RetSum n)   | trim_all || trim_sums = NoCPR-                       | otherwise             = RetSum n-    trimC RetProd      | trim_all  = NoCPR-                       | otherwise = RetProd-    trimC NoCPR = NoCPR--returnsCPR_maybe :: DmdResult -> Maybe ConTag-returnsCPR_maybe (Dunno c) = retCPR_maybe c-returnsCPR_maybe _         = Nothing--retCPR_maybe :: CPRResult -> Maybe ConTag-retCPR_maybe (RetSum t)  = Just t-retCPR_maybe RetProd     = Just fIRST_TAG-retCPR_maybe NoCPR       = Nothing+isBotDiv :: Divergence -> Bool+isBotDiv Diverges = True+isBotDiv _        = False  -- See Notes [Default demand on free variables] -- and [defaultDmd vs. resTypeArgDmd]-defaultDmd :: Termination r -> Demand-defaultDmd (Dunno {}) = absDmd-defaultDmd _          = botDmd  -- Diverges+defaultDmd :: Divergence -> Demand+defaultDmd Dunno = absDmd+defaultDmd _     = botDmd  -- Diverges -resTypeArgDmd :: Termination r -> Demand+resTypeArgDmd :: Divergence -> Demand -- TopRes and BotRes are polymorphic, so that --      BotRes === (Bot -> BotRes) === ... --      TopRes === (Top -> TopRes) === ... -- This function makes that concrete -- Also see Note [defaultDmd vs. resTypeArgDmd]-resTypeArgDmd (Dunno _) = topDmd-resTypeArgDmd _         = botDmd   -- Diverges+resTypeArgDmd Dunno = topDmd+resTypeArgDmd _     = botDmd   -- Diverges  {- Note [defaultDmd and resTypeArgDmd]@@ -1070,12 +991,12 @@                   DmdEnv        -- Demand on explicitly-mentioned                                 --      free variables                   [Demand]      -- Demand on arguments-                  DmdResult     -- See [Nature of result demand]+                  Divergence     -- See [Nature of result demand]  {- Note [Nature of result demand] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A DmdResult contains information about termination (currently distinguishing+A Divergence contains information about termination (currently distinguishing definite divergence and no information; it is possible to include definite convergence here), and CPR information about the result. @@ -1110,10 +1031,10 @@ now h puts a demand of <C(S)> onto its argument, and the demand transformer turns it into   <S>b-Now the DmdResult "b" does apply to us, even though "b1 `seq` ()" does not+Now the Divergence "b" does apply to us, even though "b1 `seq` ()" does not diverge, and we do not anything being passed to b. -Note [Asymmetry of 'both' for DmdType and DmdResult]+Note [Asymmetry of 'both' for DmdType and Divergence] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 'both' for DmdTypes is *asymmetrical*, because there is only one result!  For example, given (e1 e2), we get a DmdType dt1 for e1, use@@ -1129,21 +1050,21 @@  3. combine the termination results, but  4. take CPR info from the first argument. -3 and 4 are implemented in bothDmdResult.+3 and 4 are implemented in bothDivergence. -}  -- Equality needed for fixpoints in DmdAnal instance Eq DmdType where-  (==) (DmdType fv1 ds1 res1)-       (DmdType fv2 ds2 res2) = nonDetUFMToList fv1 == nonDetUFMToList fv2+  (==) (DmdType fv1 ds1 div1)+       (DmdType fv2 ds2 div2) = nonDetUFMToList fv1 == nonDetUFMToList fv2          -- It's OK to use nonDetUFMToList here because we're testing for          -- equality and even though the lists will be in some arbitrary          -- Unique order, it is the same order for both-                              && ds1 == ds2 && res1 == res2+                              && ds1 == ds2 && div1 == div2  lubDmdType :: DmdType -> DmdType -> DmdType lubDmdType d1 d2-  = DmdType lub_fv lub_ds lub_res+  = DmdType lub_fv lub_ds lub_div   where     n = max (dmdTypeDepth d1) (dmdTypeDepth d2)     (DmdType fv1 ds1 r1) = ensureArgs n d1@@ -1151,7 +1072,7 @@      lub_fv  = plusVarEnv_CD lubDmd fv1 (defaultDmd r1) fv2 (defaultDmd r2)     lub_ds  = zipWithEqual "lubDmdType" lubDmd ds1 ds2-    lub_res = lubDmdResult r1 r2+    lub_div = lubDivergence r1 r2  {- Note [The need for BothDmdArg]@@ -1163,25 +1084,25 @@ only passing the relevant information. -} -type BothDmdArg = (DmdEnv, Termination ())+type BothDmdArg = (DmdEnv, Divergence)  mkBothDmdArg :: DmdEnv -> BothDmdArg-mkBothDmdArg env = (env, Dunno ())+mkBothDmdArg env = (env, Dunno)  toBothDmdArg :: DmdType -> BothDmdArg toBothDmdArg (DmdType fv _ r) = (fv, go r)   where-    go (Dunno {}) = Dunno ()-    go Diverges   = Diverges+    go Dunno    = Dunno+    go Diverges = Diverges  bothDmdType :: DmdType -> BothDmdArg -> DmdType bothDmdType (DmdType fv1 ds1 r1) (fv2, t2)-    -- See Note [Asymmetry of 'both' for DmdType and DmdResult]+    -- See Note [Asymmetry of 'both' for DmdType and Divergence]     -- 'both' takes the argument/result info from its *first* arg,     -- using its second arg just for its free-var info.   = DmdType (plusVarEnv_CD bothDmd fv1 (defaultDmd r1) fv2 (defaultDmd t2))             ds1-            (r1 `bothDmdResult` t2)+            (r1 `bothDivergence` t2)  instance Outputable DmdType where   ppr (DmdType fv ds res)@@ -1202,19 +1123,15 @@ -- Note that it is ''not'' the top of the lattice (which would be "may use everything"), -- so it is (no longer) called topDmd nopDmdType, botDmdType :: DmdType-nopDmdType = DmdType emptyDmdEnv [] topRes-botDmdType = DmdType emptyDmdEnv [] botRes--cprProdDmdType :: Arity -> DmdType-cprProdDmdType arity-  = DmdType emptyDmdEnv [] (vanillaCprProdRes arity)+nopDmdType = DmdType emptyDmdEnv [] topDiv+botDmdType = DmdType emptyDmdEnv [] botDiv  isTopDmdType :: DmdType -> Bool isTopDmdType (DmdType env [] res)-  | isTopRes res && isEmptyVarEnv env = True+  | isTopDiv res && isEmptyVarEnv env = True isTopDmdType _                        = False -mkDmdType :: DmdEnv -> [Demand] -> DmdResult -> DmdType+mkDmdType :: DmdEnv -> [Demand] -> Divergence -> DmdType mkDmdType fv ds res = DmdType fv ds res  dmdTypeDepth :: DmdType -> Arity@@ -1222,7 +1139,7 @@  -- | This makes sure we can use the demand type with n arguments. -- It extends the argument list with the correct resTypeArgDmd.--- It also adjusts the DmdResult: Divergence survives additional arguments,+-- It also adjusts the Divergence: Divergence survives additional arguments, -- CPR information does not (and definite converge also would not). ensureArgs :: Arity -> DmdType -> DmdType ensureArgs n d | n == depth = d@@ -1232,13 +1149,13 @@          ds' = take n (ds ++ repeat (resTypeArgDmd r))         r' = case r of    -- See [Nature of result demand]-              Dunno _ -> topRes-              _       -> r+              Dunno -> topDiv+              _     -> r   seqDmdType :: DmdType -> () seqDmdType (DmdType env ds res) =-  seqDmdEnv env `seq` seqDemandList ds `seq` seqDmdResult res `seq` ()+  seqDmdEnv env `seq` seqDemandList ds `seq` res `seq` ()  seqDmdEnv :: DmdEnv -> () seqDmdEnv env = seqEltsUFM seqDemandList env@@ -1264,7 +1181,7 @@         DmdType fv ds _ -> DmdType fv ds (defer_res res)   where   defer_res r@(Dunno {}) = r-  defer_res _            = topRes  -- Diverges+  defer_res _            = topDiv  -- Diverges  strictenDmd :: Demand -> CleanDemand strictenDmd (JD { sd = s, ud = u})@@ -1302,15 +1219,11 @@ -- see Note [The need for BothDmdArg] postProcessDmdType :: DmdShell -> DmdType -> BothDmdArg postProcessDmdType du@(JD { sd = ss }) (DmdType fv _ res_ty)-    = (postProcessDmdEnv du fv, term_info)-    where-       term_info = case postProcessDmdResult ss res_ty of-                     Dunno _   -> Dunno ()-                     Diverges  -> Diverges+    = (postProcessDmdEnv du fv, postProcessDivergence ss res_ty) -postProcessDmdResult :: Str () -> DmdResult -> DmdResult-postProcessDmdResult Lazy _   = topRes-postProcessDmdResult _    res = res+postProcessDivergence :: Str () -> Divergence -> Divergence+postProcessDivergence Lazy _   = topDiv+postProcessDivergence _    res = res  postProcessDmdEnv :: DmdShell -> DmdEnv -> DmdEnv postProcessDmdEnv ds@(JD { sd = ss, ud = us }) env@@ -1333,7 +1246,7 @@ postProcessUnsat ds@(JD { sd = ss }) (DmdType fv args res_ty)   = DmdType (postProcessDmdEnv ds fv)             (map (postProcessDmd ds) args)-            (postProcessDmdResult ss res_ty)+            (postProcessDivergence ss res_ty)  postProcessDmd :: DmdShell -> Demand -> Demand postProcessDmd (JD { sd = ss, ud = us }) (JD { sd = s, ud = a})@@ -1451,7 +1364,7 @@     For the usage component, we use Absent. So we use either absDmd or botDmd. -Also note the equations for lubDmdResult (resp. bothDmdResult) noted there.+Also note the equations for lubDivergence (resp. bothDivergence) noted there.  Note [Always analyse in virgin pass] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1559,7 +1472,7 @@  This DmdType gives the demands unleashed by the Id when it is applied to as many arguments as are given in by the arg demands in the DmdType.-Also see Note [Nature of result demand] for the meaning of a DmdResult in a+Also see Note [Nature of result demand] for the meaning of a Divergence in a strictness signature.  If an Id is applied to less arguments than its arity, it means that@@ -1593,7 +1506,7 @@     ----------------------------------------------------     <S           ,HU              >  |  <L,U><L,U>{}     <C(C(S     )),C1(C1(U       ))>  |  <S,U><L,U>{}-    <C(C(S(S,L))),C1(C1(U(1*U,A)))>  |  <S,1*HU><S,1*U>{}+    <C(C(S(S,L))),C1(C1(U(1*U,A)))>  |  <S,1*HU><L,A>{}  Note that in the first example, the depth of the demand type was *higher* than the arity of the incoming call demand due to the anonymous lambda.@@ -1642,10 +1555,10 @@ mkStrictSigForArity :: Arity -> DmdType -> StrictSig mkStrictSigForArity arity dmd_ty = StrictSig (ensureArgs arity dmd_ty) -mkClosedStrictSig :: [Demand] -> DmdResult -> StrictSig+mkClosedStrictSig :: [Demand] -> Divergence -> StrictSig mkClosedStrictSig ds res = mkStrictSigForArity (length ds) (DmdType emptyDmdEnv ds res) -splitStrictSig :: StrictSig -> ([Demand], DmdResult)+splitStrictSig :: StrictSig -> ([Demand], Divergence) splitStrictSig (StrictSig (DmdType _ dmds res)) = (dmds, res)  increaseStrictSigArity :: Int -> StrictSig -> StrictSig@@ -1686,14 +1599,14 @@  -- | True if the signature diverges or throws an exception isBottomingSig :: StrictSig -> Bool-isBottomingSig (StrictSig (DmdType _ _ res)) = isBotRes res+isBottomingSig (StrictSig (DmdType _ _ res)) = isBotDiv res  nopSig, botSig :: StrictSig nopSig = StrictSig nopDmdType botSig = StrictSig botDmdType  cprProdSig :: Arity -> StrictSig-cprProdSig arity = StrictSig (cprProdDmdType arity)+cprProdSig _arity = nopSig  seqStrictSig :: StrictSig -> () seqStrictSig (StrictSig ty) = seqDmdType ty@@ -1739,7 +1652,7 @@    | (cd',defer_use) <- peelCallDmd cd    , Just jds <- splitProdDmd_maybe dict_dmd    = postProcessUnsat defer_use $-     DmdType emptyDmdEnv [mkOnceUsedDmd $ mkProdDmd $ map (enhance cd') jds] topRes+     DmdType emptyDmdEnv [mkOnceUsedDmd $ mkProdDmd $ map (enhance cd') jds] topDiv    | otherwise    = nopDmdType              -- See Note [Demand transformer for a dictionary selector]   where@@ -1829,7 +1742,7 @@ -- See Note [Unsaturated applications] appIsBottom :: StrictSig -> Int -> Bool appIsBottom (StrictSig (DmdType _ ds res)) n-            | isBotRes res                   = not $ lengthExceeds ds n+            | isBotDiv res                   = not $ lengthExceeds ds n appIsBottom _                              _ = False  {-@@ -2082,23 +1995,11 @@            dr <- get bh            return (DmdType emptyDmdEnv ds dr) -instance Binary DmdResult where-  put_ bh (Dunno c)     = do { putByte bh 0; put_ bh c }-  put_ bh Diverges      = putByte bh 1+instance Binary Divergence where+  put_ bh Dunno    = putByte bh 0+  put_ bh Diverges = putByte bh 1    get bh = do { h <- getByte bh               ; case h of-                  0 -> do { c <- get bh; return (Dunno c) }+                  0 -> return Dunno                   _ -> return Diverges }--instance Binary CPRResult where-    put_ bh (RetSum n)   = do { putByte bh 0; put_ bh n }-    put_ bh RetProd      = putByte bh 1-    put_ bh NoCPR        = putByte bh 2--    get  bh = do-            h <- getByte bh-            case h of-              0 -> do { n <- get bh; return (RetSum n) }-              1 -> return RetProd-              _ -> return NoCPR

compiler/basicTypes/Id.hs view

@@ -107,9 +107,11 @@          setIdDemandInfo,         setIdStrictness,+        setIdCprInfo,          idDemandInfo,         idStrictness,+        idCprInfo,      ) where @@ -117,8 +119,8 @@  import GhcPrelude -import DynFlags-import CoreSyn ( CoreRule, isStableUnfolding, evaldUnfolding,+import GHC.Driver.Session+import GHC.Core ( CoreRule, isStableUnfolding, evaldUnfolding,                  isCompulsoryUnfolding, Unfolding( NoUnfolding ) )  import IdInfo@@ -137,6 +139,7 @@ import TysPrim import DataCon import Demand+import Cpr import Name import Module import Class@@ -164,6 +167,7 @@            `setIdDemandInfo`,           `setIdStrictness`,+          `setIdCprInfo`,            `asJoinId`,           `asJoinId_maybe`@@ -370,7 +374,7 @@ of reasons:   * We want to treat them as free variables for the purpose of-   dependency analysis (e.g. CoreFVs.exprFreeVars).+   dependency analysis (e.g. GHC.Core.FVs.exprFreeVars).   * Look them up in the current substitution when we come across    occurrences of them (in Subst.lookupIdSubst). Lacking this we@@ -561,7 +565,7 @@   bad :: forall (a :: TYPE r). a -> a   bad = unsafeCoerce# -The desugar has special magic to detect such cases: DsExpr.badUseOfLevPolyPrimop.+The desugar has special magic to detect such cases: GHC.HsToCore.Expr.badUseOfLevPolyPrimop. And we want that magic to apply to levity-polymorphic compulsory-inline things. The easiest way to do this is for hasNoBinding to return True of all things that have compulsory unfolding.  Some Ids with a compulsory unfolding also@@ -645,6 +649,12 @@ setIdStrictness :: Id -> StrictSig -> Id setIdStrictness id sig = modifyIdInfo (`setStrictnessInfo` sig) id +idCprInfo :: Id -> CprSig+idCprInfo id = cprInfo (idInfo id)++setIdCprInfo :: Id -> CprSig -> Id+setIdCprInfo id sig = modifyIdInfo (\info -> setCprInfo info sig) id+ zapIdStrictness :: Id -> Id zapIdStrictness id = modifyIdInfo (`setStrictnessInfo` nopSig) id @@ -768,7 +778,7 @@ idOneShotInfo id = oneShotInfo (idInfo id)  -- | Like 'idOneShotInfo', but taking the Horrible State Hack in to account--- See Note [The state-transformer hack] in CoreArity+-- See Note [The state-transformer hack] in GHC.Core.Arity idStateHackOneShotInfo :: Id -> OneShotInfo idStateHackOneShotInfo id     | isStateHackType (idType id) = stateHackOneShot@@ -778,7 +788,7 @@ -- This one is the "business end", called externally. -- It works on type variables as well as Ids, returning True -- Its main purpose is to encapsulate the Horrible State Hack--- See Note [The state-transformer hack] in CoreArity+-- See Note [The state-transformer hack] in GHC.Core.Arity isOneShotBndr :: Var -> Bool isOneShotBndr var   | isTyVar var                              = True@@ -948,11 +958,13 @@      old_strictness  = strictnessInfo old_info     new_strictness  = increaseStrictSigArity arity_increase old_strictness+    old_cpr         = cprInfo old_info      transfer new_info = new_info `setArityInfo` new_arity                                  `setInlinePragInfo` old_inline_prag                                  `setOccInfo` new_occ_info                                  `setStrictnessInfo` new_strictness+                                 `setCprInfo` old_cpr  isNeverLevPolyId :: Id -> Bool isNeverLevPolyId = isNeverLevPolyIdInfo . idInfo

compiler/basicTypes/IdInfo.hs view

@@ -42,6 +42,7 @@          -- ** Demand and strictness Info         strictnessInfo, setStrictnessInfo,+        cprInfo, setCprInfo,         demandInfo, setDemandInfo, pprStrictness,          -- ** Unfolding Info@@ -85,7 +86,7 @@  import GhcPrelude -import CoreSyn+import GHC.Core  import Class import {-# SOURCE #-} PrimOp (PrimOp)@@ -100,6 +101,7 @@ import Outputable import Module import Demand+import Cpr import Util  -- infixl so you can say (id `set` a `set` b)@@ -111,6 +113,7 @@           `setOccInfo`,           `setCafInfo`,           `setStrictnessInfo`,+          `setCprInfo`,           `setDemandInfo`,           `setNeverLevPoly`,           `setLevityInfoWithType`@@ -162,7 +165,7 @@                -- This only covers /un-lifted/ coercions, of type                -- (t1 ~# t2) or (t1 ~R# t2), not their lifted variants   | JoinId JoinArity           -- ^ An 'Id' for a join point taking n arguments-       -- Note [Join points] in CoreSyn+       -- Note [Join points] in GHC.Core  -- | Recursive Selector Parent data RecSelParent = RecSelData TyCon | RecSelPatSyn PatSyn deriving Eq@@ -239,7 +242,7 @@ data IdInfo   = IdInfo {         arityInfo       :: !ArityInfo,-        -- ^ 'Id' arity, as computed by 'CoreArity'. Specifies how many+        -- ^ 'Id' arity, as computed by 'GHC.Core.Arity'. Specifies how many         -- arguments this 'Id' has to be applied to before it doesn any         -- meaningful work.         ruleInfo        :: RuleInfo,@@ -258,6 +261,9 @@         strictnessInfo  :: StrictSig,         -- ^ A strictness signature. Digests how a function uses its arguments         -- if applied to at least 'arityInfo' arguments.+        cprInfo         :: CprSig,+        -- ^ Information on whether the function will ultimately return a+        -- freshly allocated constructor.         demandInfo      :: Demand,         -- ^ ID demand information         callArityInfo   :: !ArityInfo,@@ -302,6 +308,9 @@ setStrictnessInfo :: IdInfo -> StrictSig -> IdInfo setStrictnessInfo info dd = dd `seq` info { strictnessInfo = dd } +setCprInfo :: IdInfo -> CprSig -> IdInfo+setCprInfo info cpr = cpr `seq` info { cprInfo = cpr }+ -- | Basic 'IdInfo' that carries no useful information whatsoever vanillaIdInfo :: IdInfo vanillaIdInfo@@ -315,6 +324,7 @@             occInfo             = noOccInfo,             demandInfo          = topDmd,             strictnessInfo      = nopSig,+            cprInfo             = topCprSig,             callArityInfo       = unknownArity,             levityInfo          = NoLevityInfo            }@@ -607,7 +617,7 @@ of saturation. This is helpful in optimizing the levity-polymorphism check done in the desugarer, where we can usually learn that something is not levity-polymorphic without actually figuring out its type. See-isExprLevPoly in CoreUtils for where this info is used. Storing+isExprLevPoly in GHC.Core.Utils for where this info is used. Storing this is required to prevent perf/compiler/T5631 from blowing up.  -}

compiler/basicTypes/Literal.hs view

@@ -61,7 +61,7 @@ import BasicTypes import Binary import Constants-import DynFlags+import GHC.Driver.Session import GHC.Platform import UniqFM import Util@@ -599,7 +599,7 @@ -- structured, ensuring that the compiler can't inline in ways that will break -- user code. One approach to this is described in #8472. litIsTrivial :: Literal -> Bool---      c.f. CoreUtils.exprIsTrivial+--      c.f. GHC.Core.Utils.exprIsTrivial litIsTrivial (LitString _)      = False litIsTrivial (LitNumber nt _ _) = case nt of   LitNumInteger -> False@@ -612,7 +612,7 @@  -- | True if code space does not go bad if we duplicate this literal litIsDupable :: DynFlags -> Literal -> Bool---      c.f. CoreUtils.exprIsDupable+--      c.f. GHC.Core.Utils.exprIsDupable litIsDupable _      (LitString _)      = False litIsDupable dflags (LitNumber nt i _) = case nt of   LitNumInteger -> inIntRange dflags i@@ -846,6 +846,6 @@   it in the code generators, but it seems simpler to do it   once and for all in CoreToSTG. -  In ByteCodeAsm we just lower it as a 0 literal, because+  In GHC.ByteCode.Asm we just lower it as a 0 literal, because   it's all boxed and lifted to the host GC anyway. -}

compiler/basicTypes/MkId.hs view

@@ -22,11 +22,12 @@         mkPrimOpId, mkFCallId,          unwrapNewTypeBody, wrapFamInstBody,-        DataConBoxer(..), mkDataConRep, mkDataConWorkId,+        DataConBoxer(..), vanillaDataConBoxer,+        mkDataConRep, mkDataConWorkId,          -- And some particular Ids; see below for why they are wired in         wiredInIds, ghcPrimIds,-        unsafeCoerceName, unsafeCoerceId, realWorldPrimId,+        realWorldPrimId,         voidPrimId, voidArgId,         nullAddrId, seqId, lazyId, lazyIdKey,         coercionTokenId, magicDictId, coerceId,@@ -41,17 +42,18 @@  import GhcPrelude -import Rules+import GHC.Core.Rules import TysPrim import TysWiredIn import PrelRules import Type+import TyCoRep import FamInstEnv import Coercion import TcType-import MkCore-import CoreUtils        ( mkCast, mkDefaultCase )-import CoreUnfold+import GHC.Core.Make+import GHC.Core.Utils  ( mkCast, mkDefaultCase )+import GHC.Core.Unfold import Literal import TyCon import Class@@ -63,13 +65,14 @@ import Id import IdInfo import Demand-import CoreSyn+import Cpr+import GHC.Core import Unique import UniqSupply import PrelNames import BasicTypes       hiding ( SuccessFlag(..) ) import Util-import DynFlags+import GHC.Driver.Session import Outputable import FastString import ListSetOps@@ -97,7 +100,7 @@  * magicIds: see Note [magicIds] -* errorIds, defined in coreSyn/MkCore.hs.+* errorIds, defined in GHC.Core.Make.   These error functions (e.g. rUNTIME_ERROR_ID) are wired in   because the desugarer generates code that mentions them directly @@ -141,7 +144,7 @@ wiredInIds   =  magicIds   ++ ghcPrimIds-  ++ errorIds           -- Defined in MkCore+  ++ errorIds           -- Defined in GHC.Core.Make  magicIds :: [Id]    -- See Note [magicIds] magicIds = [lazyId, oneShotId, noinlineId]@@ -150,7 +153,6 @@ ghcPrimIds   = [ realWorldPrimId     , voidPrimId-    , unsafeCoerceId     , nullAddrId     , seqId     , magicDictId@@ -350,10 +352,10 @@ polymorphic. It's OK because MkN evaporates in the compiled code, becoming just a cast. That is, it has a compulsory unfolding. As long as its argument is not levity-polymorphic (which it can't be, according to-Note [Levity polymorphism invariants] in CoreSyn), and it's saturated,+Note [Levity polymorphism invariants] in GHC.Core), and it's saturated, no levity-polymorphic code ends up in the code generator. The saturation condition is effectively checked by Note [Detecting forced eta expansion]-in DsExpr.+in GHC.HsToCore.Expr.  However, if we make a *wrapper* for a newtype, we get into trouble. The saturation condition is no longer checked (because hasNoBinding@@ -411,6 +413,7 @@     base_info = noCafIdInfo                 `setArityInfo`          1                 `setStrictnessInfo`     strict_sig+                `setCprInfo`            topCprSig                 `setLevityInfoWithType` sel_ty      info | new_tycon@@ -439,7 +442,7 @@         -- It's worth giving one, so that absence info etc is generated         -- even if the selector isn't inlined -    strict_sig = mkClosedStrictSig [arg_dmd] topRes+    strict_sig = mkClosedStrictSig [arg_dmd] topDiv     arg_dmd | new_tycon = evalDmd             | otherwise = mkManyUsedDmd $                           mkProdDmd [ if name == sel_name then evalDmd else absDmd@@ -507,6 +510,7 @@     alg_wkr_info = noCafIdInfo                    `setArityInfo`          wkr_arity                    `setStrictnessInfo`     wkr_sig+                   `setCprInfo`            mkCprSig wkr_arity (dataConCPR data_con)                    `setUnfoldingInfo`      evaldUnfolding  -- Record that it's evaluated,                                                            -- even if arity = 0                    `setLevityInfoWithType` wkr_ty@@ -514,7 +518,7 @@                      -- setNeverLevPoly      wkr_arity = dataConRepArity data_con-    wkr_sig   = mkClosedStrictSig (replicate wkr_arity topDmd) (dataConCPR data_con)+    wkr_sig   = mkClosedStrictSig (replicate wkr_arity topDmd) topDiv         --      Note [Data-con worker strictness]         -- Notice that we do *not* say the worker Id is strict         -- even if the data constructor is declared strict@@ -552,19 +556,17 @@                    mkLams univ_tvs $ Lam id_arg1 $                    wrapNewTypeBody tycon res_ty_args (Var id_arg1) -dataConCPR :: DataCon -> DmdResult+dataConCPR :: DataCon -> CprResult dataConCPR con   | isDataTyCon tycon     -- Real data types only; that is,                           -- not unboxed tuples or newtypes   , null (dataConExTyCoVars con)  -- No existentials   , wkr_arity > 0   , wkr_arity <= mAX_CPR_SIZE-  = if is_prod then vanillaCprProdRes (dataConRepArity con)-               else cprSumRes (dataConTag con)+  = conCpr (dataConTag con)   | otherwise-  = topRes+  = topCpr   where-    is_prod   = isProductTyCon tycon     tycon     = dataConTyCon con     wkr_arity = dataConRepArity con @@ -600,6 +602,10 @@                        -- Bind these src-level vars, returning the                        -- rep-level vars to bind in the pattern +vanillaDataConBoxer :: DataConBoxer+-- No transformation on arguments needed+vanillaDataConBoxer = DCB (\_tys args -> return (args, []))+ {- Note [Inline partially-applied constructor wrappers] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -651,12 +657,13 @@                          `setInlinePragInfo`    wrap_prag                          `setUnfoldingInfo`     wrap_unf                          `setStrictnessInfo`    wrap_sig+                         `setCprInfo`           mkCprSig wrap_arity (dataConCPR data_con)                              -- We need to get the CAF info right here because GHC.Iface.Tidy                              -- does not tidy the IdInfo of implicit bindings (like the wrapper)                              -- so it not make sure that the CAF info is sane                          `setLevityInfoWithType` wrap_ty -             wrap_sig = mkClosedStrictSig wrap_arg_dmds (dataConCPR data_con)+             wrap_sig = mkClosedStrictSig wrap_arg_dmds topDiv               wrap_arg_dmds =                replicate (length theta) topDmd ++ map mk_dmd arg_ibangs@@ -664,7 +671,7 @@                -- the strictness signature (#14290).               mk_dmd str | isBanged str = evalDmd-                        | otherwise           = topDmd+                        | otherwise    = topDmd               wrap_prag = alwaysInlinePragma `setInlinePragmaActivation`                          activeDuringFinal@@ -1218,10 +1225,16 @@                          (AnId id) UserSyntax     id   = mkGlobalId (PrimOpId prim_op) name ty info +    -- PrimOps don't ever construct a product, but we want to preserve bottoms+    cpr+      | isBotDiv (snd (splitStrictSig strict_sig)) = botCpr+      | otherwise                                  = topCpr+     info = noCafIdInfo            `setRuleInfo`           mkRuleInfo (maybeToList $ primOpRules name prim_op)            `setArityInfo`          arity            `setStrictnessInfo`     strict_sig+           `setCprInfo`            mkCprSig arity cpr            `setInlinePragInfo`     neverInlinePragma            `setLevityInfoWithType` res_ty                -- We give PrimOps a NOINLINE pragma so that we don't@@ -1254,11 +1267,12 @@     info = noCafIdInfo            `setArityInfo`          arity            `setStrictnessInfo`     strict_sig+           `setCprInfo`            topCprSig            `setLevityInfoWithType` ty      (bndrs, _) = tcSplitPiTys ty     arity      = count isAnonTyCoBinder bndrs-    strict_sig = mkClosedStrictSig (replicate arity topDmd) topRes+    strict_sig = mkClosedStrictSig (replicate arity topDmd) topDiv     -- the call does not claim to be strict in its arguments, since they     -- may be lifted (foreign import prim) and the called code doesn't     -- necessarily force them. See #11076.@@ -1313,19 +1327,14 @@ does.  If we had a way to get a compulsory unfolding from an interface file, we could do that, but we don't right now. -unsafeCoerce# isn't so much a PrimOp as a phantom identifier, that-just gets expanded into a type coercion wherever it occurs.  Hence we-add it as a built-in Id with an unfolding here.- The type variables we use here are "open" type variables: this means they can unify with both unlifted and lifted types.  Hence we provide another gun with which to shoot yourself in the foot. -} -unsafeCoerceName, nullAddrName, seqName,+nullAddrName, seqName,    realWorldName, voidPrimIdName, coercionTokenName,    magicDictName, coerceName, proxyName :: Name-unsafeCoerceName  = mkWiredInIdName gHC_PRIM  (fsLit "unsafeCoerce#")  unsafeCoerceIdKey  unsafeCoerceId nullAddrName      = mkWiredInIdName gHC_PRIM  (fsLit "nullAddr#")      nullAddrIdKey      nullAddrId seqName           = mkWiredInIdName gHC_PRIM  (fsLit "seq")            seqIdKey           seqId realWorldName     = mkWiredInIdName gHC_PRIM  (fsLit "realWorld#")     realWorldPrimIdKey realWorldPrimId@@ -1357,28 +1366,6 @@     ty      = mkInvForAllTy kv $ mkSpecForAllTy tv $ mkProxyPrimTy kv_ty tv_ty  -------------------------------------------------unsafeCoerceId :: Id-unsafeCoerceId-  = pcMiscPrelId unsafeCoerceName ty info-  where-    info = noCafIdInfo `setInlinePragInfo` alwaysInlinePragma-                       `setUnfoldingInfo`  mkCompulsoryUnfolding rhs--    -- unsafeCoerce# :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)-    --                         (a :: TYPE r1) (b :: TYPE r2).-    --                         a -> b-    bndrs = mkTemplateKiTyVars [runtimeRepTy, runtimeRepTy]-                               (\ks -> map tYPE ks)--    [_, _, a, b] = mkTyVarTys bndrs--    ty  = mkSpecForAllTys bndrs (mkVisFunTy a b)--    [x] = mkTemplateLocals [a]-    rhs = mkLams (bndrs ++ [x]) $-          Cast (Var x) (mkUnsafeCo Representational a b)-------------------------------------------------- nullAddrId :: Id -- nullAddr# :: Addr# -- The reason it is here is because we don't provide@@ -1400,7 +1387,7 @@          = alwaysInlinePragma `setInlinePragmaActivation` ActiveAfter                  NoSourceText 0                   -- Make 'seq' not inline-always, so that simpleOptExpr-                  -- (see CoreSubst.simple_app) won't inline 'seq' on the+                  -- (see GHC.Core.Subst.simple_app) won't inline 'seq' on the                   -- LHS of rules.  That way we can have rules for 'seq';                   -- see Note [seqId magic] @@ -1478,22 +1465,6 @@           [(DataAlt coercibleDataCon, [eq], Cast (Var x) (mkCoVarCo eq))]  {--Note [Unsafe coerce magic]-~~~~~~~~~~~~~~~~~~~~~~~~~~-We define a *primitive*-   GHC.Prim.unsafeCoerce#-and then in the base library we define the ordinary function-   Unsafe.Coerce.unsafeCoerce :: forall (a:*) (b:*). a -> b-   unsafeCoerce x = unsafeCoerce# x--Notice that unsafeCoerce has a civilized (albeit still dangerous)-polymorphic type, whose type args have kind *.  So you can't use it on-unboxed values (unsafeCoerce 3#).--In contrast unsafeCoerce# is even more dangerous because you *can* use-it on unboxed things, (unsafeCoerce# 3#) :: Int. Its type is-   forall (r1 :: RuntimeRep) (r2 :: RuntimeRep) (a: TYPE r1) (b: TYPE r2). a -> b- Note [seqId magic] ~~~~~~~~~~~~~~~~~~ 'GHC.Prim.seq' is special in several ways.@@ -1501,7 +1472,7 @@ a) Its fixity is set in GHC.Iface.Load.ghcPrimIface  b) It has quite a bit of desugaring magic.-   See DsUtils.hs Note [Desugaring seq (1)] and (2) and (3)+   See GHC.HsToCore.Utils.hs Note [Desugaring seq (1)] and (2) and (3)  c) There is some special rule handing: Note [User-defined RULES for seq] @@ -1640,7 +1611,7 @@  It is only effective if the one-shot info survives as long as possible; in particular it must make it into the interface in unfoldings. See Note [Preserve-OneShotInfo] in CoreTidy.+OneShotInfo] in GHC.Core.Op.Tidy.  Also see https://gitlab.haskell.org/ghc/ghc/wikis/one-shot. @@ -1722,7 +1693,7 @@ voidArgId = mkSysLocal (fsLit "void") voidArgIdKey voidPrimTy  coercionTokenId :: Id         -- :: () ~ ()-coercionTokenId -- Used to replace Coercion terms when we go to STG+coercionTokenId -- See Note [Coercion tokens] in CoreToStg.hs   = pcMiscPrelId coercionTokenName                  (mkTyConApp eqPrimTyCon [liftedTypeKind, liftedTypeKind, unitTy, unitTy])                  noCafIdInfo

compiler/basicTypes/Module.hs view

@@ -146,7 +146,7 @@ import FastString import Binary import Util-import Data.List+import Data.List (sortBy, sort) import Data.Ord import GHC.PackageDb (BinaryStringRep(..), DbUnitIdModuleRep(..), DbModule(..), DbUnitId(..)) import Fingerprint@@ -169,8 +169,8 @@ import qualified FiniteMap as Map import System.FilePath -import {-# SOURCE #-} DynFlags (DynFlags)-import {-# SOURCE #-} Packages (componentIdString, improveUnitId, UnitInfoMap, getUnitInfoMap, displayInstalledUnitId)+import {-# SOURCE #-} GHC.Driver.Session (DynFlags)+import {-# SOURCE #-} GHC.Driver.Packages (componentIdString, improveUnitId, UnitInfoMap, getUnitInfoMap, displayInstalledUnitId)  -- Note [The identifier lexicon] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

compiler/basicTypes/Name.hs view

@@ -90,7 +90,6 @@ import Util import Maybes import Binary-import DynFlags import FastString import Outputable @@ -273,7 +272,7 @@ -- each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come -- from the magic 'interactive' package; and all the details are kept in the -- TcLclEnv, TcGblEnv, NOT in the HPT or EPT.--- See Note [The interactive package] in HscTypes+-- See Note [The interactive package] in GHC.Driver.Types  nameIsLocalOrFrom from name   | Just mod <- nameModule_maybe name = from == mod || isInteractiveModule mod@@ -561,10 +560,8 @@                     _ -> braces (ppr (moduleName mod) <> dot <> ppr_occ_name occ)             else pprModulePrefix sty mod occ <> ppr_occ_name occ   where-    pp_mod = sdocWithDynFlags $ \dflags ->-             if gopt Opt_SuppressModulePrefixes dflags-             then empty-             else ppr mod <> dot+    pp_mod = ppUnlessOption sdocSuppressModulePrefixes+               (ppr mod <> dot)  pprInternal :: PprStyle -> Unique -> OccName -> SDoc pprInternal sty uniq occ@@ -590,11 +587,8 @@  pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc -- Print the "M." part of a name, based on whether it's in scope or not--- See Note [Printing original names] in HscTypes-pprModulePrefix sty mod occ = sdocWithDynFlags $ \dflags ->-  if gopt Opt_SuppressModulePrefixes dflags-  then empty-  else+-- See Note [Printing original names] in GHC.Driver.Types+pprModulePrefix sty mod occ = ppUnlessOption sdocSuppressModulePrefixes $     case qualName sty mod occ of              -- See Outputable.QualifyName:       NameQual modname -> ppr modname <> dot       -- Name is in scope       NameNotInScope1  -> ppr mod <> dot           -- Not in scope@@ -605,17 +599,15 @@ pprUnique :: Unique -> SDoc -- Print a unique unless we are suppressing them pprUnique uniq-  = sdocWithDynFlags $ \dflags ->-    ppUnless (gopt Opt_SuppressUniques dflags) $-    pprUniqueAlways uniq+  = ppUnlessOption sdocSuppressUniques $+      pprUniqueAlways uniq  ppr_underscore_unique :: Unique -> SDoc -- Print an underscore separating the name from its unique -- But suppress it if we aren't printing the uniques anyway ppr_underscore_unique uniq-  = sdocWithDynFlags $ \dflags ->-    ppUnless (gopt Opt_SuppressUniques dflags) $-    char '_' <> pprUniqueAlways uniq+  = ppUnlessOption sdocSuppressUniques $+      char '_' <> pprUniqueAlways uniq  ppr_occ_name :: OccName -> SDoc ppr_occ_name occ = ftext (occNameFS occ)@@ -640,7 +632,7 @@          -- nameSrcLoc rather than nameSrcSpan          -- It seems less cluttered to show a location          -- rather than a span for the definition point-       RealSrcLoc s -> text "at" <+> ppr s+       RealSrcLoc s _ -> text "at" <+> ppr s        UnhelpfulLoc s          | isInternalName name || isSystemName name          -> text "at" <+> ftext s

compiler/basicTypes/NameCache.hs view

@@ -66,8 +66,8 @@     turned into an Orig RdrName.    * Template Haskell turns a BuiltInSyntax Name into a TH.NameG-    (DsMeta.globalVar), and parses a NameG into an Orig RdrName-    (Convert.thRdrName).  So, e.g. $(do { reify '(,); ... }) will+    (GHC.HsToCore.Quote.globalVar), and parses a NameG into an Orig RdrName+    (GHC.ThToHs.thRdrName).  So, e.g. $(do { reify '(,); ... }) will     go this route (#8954).  -}

compiler/basicTypes/NameEnv.hs view

@@ -6,6 +6,9 @@ -}  {-# LANGUAGE CPP #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE ScopedTypeVariables #-}+ module NameEnv (         -- * Var, Id and TyVar environments (maps)         NameEnv,@@ -60,7 +63,8 @@ in Note [Deterministic SCC] in Digraph. -} -depAnal :: (node -> [Name])      -- Defs+depAnal :: forall node.+           (node -> [Name])      -- Defs         -> (node -> [Name])      -- Uses         -> [node]         -> [SCC node]@@ -69,11 +73,13 @@ -- -- The get_defs and get_uses functions are called only once per node depAnal get_defs get_uses nodes-  = stronglyConnCompFromEdgedVerticesUniq (map mk_node keyed_nodes)+  = stronglyConnCompFromEdgedVerticesUniq graph_nodes   where+    graph_nodes = (map mk_node keyed_nodes) :: [Node Int node]     keyed_nodes = nodes `zip` [(1::Int)..]     mk_node (node, key) =-      DigraphNode node key (mapMaybe (lookupNameEnv key_map) (get_uses node))+      let !edges = (mapMaybe (lookupNameEnv key_map) (get_uses node))+      in DigraphNode node key edges      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]

compiler/basicTypes/OccName.hs view

@@ -6,6 +6,7 @@ {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE LambdaCase #-}  -- | -- #name_types#@@ -104,7 +105,6 @@  import Util import Unique-import DynFlags import UniqFM import UniqSet import FastString@@ -278,10 +278,9 @@     pp_debug sty | debugStyle sty = braces (pprNameSpaceBrief sp)                  | otherwise      = empty -    pp_occ = sdocWithDynFlags $ \dflags ->-             if gopt Opt_SuppressUniques dflags-             then text (strip_th_unique (unpackFS occ))-             else ftext occ+    pp_occ = sdocOption sdocSuppressUniques $ \case+               True  -> text (strip_th_unique (unpackFS occ))+               False -> ftext occ          -- See Note [Suppressing uniques in OccNames]     strip_th_unique ('[' : c : _) | isAlphaNum c = []

compiler/basicTypes/PatSyn.hs view

@@ -38,7 +38,7 @@  import qualified Data.Data as Data import Data.Function-import Data.List+import Data.List (find)  {- ************************************************************************

compiler/basicTypes/Predicate.hs view

@@ -50,7 +50,7 @@   = ClassPred Class [Type]   | EqPred EqRel Type Type   | IrredPred PredType-  | ForAllPred [TyCoVarBinder] [PredType] PredType+  | ForAllPred [TyVar] [PredType] PredType      -- ForAllPred: see Note [Quantified constraints] in TcCanonical   -- NB: There is no TuplePred case   --     Tuple predicates like (Eq a, Ord b) are just treated@@ -67,7 +67,7 @@       | Just clas <- tyConClass_maybe tc       -> ClassPred clas tys -    _ | (tvs, rho) <- splitForAllVarBndrs ev_ty+    _ | (tvs, rho) <- splitForAllTys ev_ty       , (theta, pred) <- splitFunTys rho       , not (null tvs && null theta)       -> ForAllPred tvs theta pred

compiler/basicTypes/RdrName.hs view

@@ -1033,7 +1033,7 @@     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+    [Interactively-bound Ids in GHCi] in GHC.Driver.Types    - Data types also have External Names, like Ghci4.T; but we still want     'T' to mean the newly-declared 'T', not an old one.@@ -1128,7 +1128,7 @@ -- It's quite elaborate so that we can give accurate unused-name warnings. data ImportSpec = ImpSpec { is_decl :: ImpDeclSpec,                             is_item :: ImpItemSpec }-                deriving( Eq, Ord, Data )+                deriving( Eq, Data )  -- | Import Declaration Specification --@@ -1145,7 +1145,7 @@         is_as       :: ModuleName, -- ^ Import alias, e.g. from @as M@ (or @Muggle@ if there is no @as@ clause)         is_qual     :: Bool,       -- ^ Was this import qualified?         is_dloc     :: SrcSpan     -- ^ The location of the entire import declaration-    } deriving Data+    } deriving (Eq, Data)  -- | Import Item Specification --@@ -1166,26 +1166,7 @@         --         -- Here the constructors of @T@ are not named explicitly;         -- only @T@ is named explicitly.-  deriving Data--instance Eq ImpDeclSpec where-  p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False--instance Ord ImpDeclSpec where-   compare is1 is2 = (is_mod is1 `compare` is_mod is2) `thenCmp`-                     (is_dloc is1 `compare` is_dloc is2)--instance Eq ImpItemSpec where-  p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False--instance Ord ImpItemSpec where-   compare is1 is2 =-    case (is1, is2) of-      (ImpAll, ImpAll) -> EQ-      (ImpAll, _)      -> GT-      (_, ImpAll)      -> LT-      (ImpSome _ l1, ImpSome _ l2) -> l1 `compare` l2-+  deriving (Eq, Data)  bestImport :: [ImportSpec] -> ImportSpec -- See Note [Choosing the best import declaration]@@ -1203,7 +1184,7 @@          (ImpSpec { is_item = item2, is_decl = d2 })       = (is_qual d1 `compare` is_qual d2) `thenCmp`         (best_item item1 item2)           `thenCmp`-        (is_dloc d1 `compare` is_dloc d2)+        SrcLoc.leftmost_smallest (is_dloc d1) (is_dloc d2)      best_item :: ImpItemSpec -> ImpItemSpec -> Ordering     best_item ImpAll ImpAll = EQ@@ -1325,7 +1306,7 @@             | otherwise                  = empty  pprLoc :: SrcSpan -> SDoc-pprLoc (RealSrcSpan s)    = text "at" <+> ppr s+pprLoc (RealSrcSpan s _)  = text "at" <+> ppr s pprLoc (UnhelpfulSpan {}) = empty  -- | Display info about the treatment of '*' under NoStarIsType.@@ -1376,12 +1357,12 @@ -- starInfo :: Bool -> RdrName -> SDoc starInfo star_is_type rdr_name =-  -- One might ask: if can use sdocWithDynFlags here, why bother to take-  -- star_is_type as input? Why not refactor?+  -- One might ask: if can use `sdocOption sdocStarIsType` here, why bother to+  -- take star_is_type as input? Why not refactor?   ---  -- The reason is that sdocWithDynFlags would provide DynFlags that are active-  -- in the module that tries to load the problematic definition, not-  -- in the module that is being loaded.+  -- The reason is that `sdocOption sdocStarIsType` would indicate that+  -- StarIsType is enabled in the module that tries to load the problematic+  -- definition, not in the module that is being loaded.   --   -- So if we have 'data T :: *' in a module with NoStarIsType, then the hint   -- must be displayed even if we load this definition from a module (or GHCi)

compiler/basicTypes/SrcLoc.hs view

@@ -28,6 +28,7 @@         interactiveSrcLoc,      -- Code from an interactive session          advanceSrcLoc,+        advanceBufPos,          -- ** Unsafely deconstructing SrcLoc         -- These are dubious exports, because they crash on some inputs@@ -64,6 +65,10 @@         isGoodSrcSpan, isOneLineSpan,         containsSpan, +        -- * StringBuffer locations+        BufPos(..),+        BufSpan(..),+         -- * Located         Located,         RealLocated,@@ -82,10 +87,23 @@          -- ** Combining and comparing Located values         eqLocated, cmpLocated, combineLocs, addCLoc,-        leftmost_smallest, leftmost_largest, rightmost,-        spans, isSubspanOf, sortLocated,+        leftmost_smallest, leftmost_largest, rightmost_smallest,+        spans, isSubspanOf, isRealSubspanOf, sortLocated,+        sortRealLocated,+        lookupSrcLoc, lookupSrcSpan, -        liftL+        liftL,++        -- * Parser locations+        PsLoc(..),+        PsSpan(..),+        PsLocated,+        advancePsLoc,+        mkPsSpan,+        psSpanStart,+        psSpanEnd,+        mkSrcSpanPs,+     ) where  import GhcPrelude@@ -96,10 +114,12 @@ import FastString  import Control.DeepSeq+import Control.Applicative (liftA2) import Data.Bits import Data.Data-import Data.List-import Data.Ord+import Data.List (sortBy, intercalate)+import Data.Function (on)+import qualified Data.Map as Map  {- ************************************************************************@@ -121,11 +141,21 @@                 {-# UNPACK #-} !Int     -- column number, begins at 1   deriving (Eq, Ord) +-- | 0-based index identifying the raw location in the StringBuffer.+--+-- Unlike 'RealSrcLoc', it is not affected by #line and {-# LINE ... #-}+-- pragmas. In particular, notice how 'setSrcLoc' and 'resetAlrLastLoc' in+-- Lexer.x update 'PsLoc' preserving 'BufPos'.+--+-- The parser guarantees that 'BufPos' are monotonic. See #17632.+newtype BufPos = BufPos { bufPos :: Int }+  deriving (Eq, Ord, Show)+ -- | Source Location data SrcLoc-  = RealSrcLoc {-# UNPACK #-}!RealSrcLoc+  = RealSrcLoc !RealSrcLoc !(Maybe BufPos)  -- See Note [Why Maybe BufPos]   | UnhelpfulLoc FastString     -- Just a general indication-  deriving (Eq, Ord, Show)+  deriving (Eq, Show)  {- ************************************************************************@@ -136,7 +166,7 @@ -}  mkSrcLoc :: FastString -> Int -> Int -> SrcLoc-mkSrcLoc x line col = RealSrcLoc (mkRealSrcLoc x line col)+mkSrcLoc x line col = RealSrcLoc (mkRealSrcLoc x line col) Nothing  mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc mkRealSrcLoc x line col = SrcLoc x line col@@ -168,10 +198,15 @@ -- character in any other case advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc advanceSrcLoc (SrcLoc f l _) '\n' = SrcLoc f  (l + 1) 1-advanceSrcLoc (SrcLoc f l c) '\t' = SrcLoc f  l (((((c - 1) `shiftR` 3) + 1)-                                                  `shiftL` 3) + 1)+advanceSrcLoc (SrcLoc f l c) '\t' = SrcLoc f  l (advance_tabstop c) advanceSrcLoc (SrcLoc f l c) _    = SrcLoc f  l (c + 1) +advance_tabstop :: Int -> Int+advance_tabstop c = ((((c - 1) `shiftR` 3) + 1) `shiftL` 3) + 1++advanceBufPos :: BufPos -> BufPos+advanceBufPos (BufPos i) = BufPos (i+1)+ {- ************************************************************************ *                                                                      *@@ -181,8 +216,19 @@ -}  sortLocated :: [Located a] -> [Located a]-sortLocated things = sortBy (comparing getLoc) things+sortLocated = sortBy (leftmost_smallest `on` getLoc) +sortRealLocated :: [RealLocated a] -> [RealLocated a]+sortRealLocated = sortBy (compare `on` getLoc)++lookupSrcLoc :: SrcLoc -> Map.Map RealSrcLoc a -> Maybe a+lookupSrcLoc (RealSrcLoc l _) = Map.lookup l+lookupSrcLoc (UnhelpfulLoc _) = const Nothing++lookupSrcSpan :: SrcSpan -> Map.Map RealSrcSpan a -> Maybe a+lookupSrcSpan (RealSrcSpan l _) = Map.lookup l+lookupSrcSpan (UnhelpfulSpan _) = const Nothing+ instance Outputable RealSrcLoc where     ppr (SrcLoc src_path src_line src_col)       = hcat [ pprFastFilePath src_path <> colon@@ -200,7 +246,7 @@ --                  char '\"', pprFastFilePath src_path, text " #-}"]  instance Outputable SrcLoc where-    ppr (RealSrcLoc l) = ppr l+    ppr (RealSrcLoc l _) = ppr l     ppr (UnhelpfulLoc s)  = ftext s  instance Data RealSrcSpan where@@ -245,21 +291,46 @@         }   deriving Eq +-- | StringBuffer Source Span+data BufSpan =+  BufSpan { bufSpanStart, bufSpanEnd :: {-# UNPACK #-} !BufPos }+  deriving (Eq, Ord, Show)+ -- | Source Span -- -- A 'SrcSpan' identifies either a specific portion of a text file -- or a human-readable description of a location. data SrcSpan =-    RealSrcSpan !RealSrcSpan+    RealSrcSpan !RealSrcSpan !(Maybe BufSpan)  -- See Note [Why Maybe BufPos]   | UnhelpfulSpan !FastString   -- Just a general indication                                 -- also used to indicate an empty span -  deriving (Eq, Ord, Show) -- Show is used by Lexer.x, because we-                           -- derive Show for Token+  deriving (Eq, Show) -- Show is used by Lexer.x, because we+                      -- derive Show for Token +{- Note [Why Maybe BufPos]+~~~~~~~~~~~~~~~~~~~~~~~~~~+In SrcLoc we store (Maybe BufPos); in SrcSpan we store (Maybe BufSpan).+Why the Maybe?++Surely, the lexer can always fill in the buffer position, and it guarantees to do so.+However, sometimes the SrcLoc/SrcSpan is constructed in a different context+where the buffer location is not available, and then we use Nothing instead of+a fake value like BufPos (-1).++Perhaps the compiler could be re-engineered to pass around BufPos more+carefully and never discard it, and this 'Maybe' could be removed. If you're+interested in doing so, you may find this ripgrep query useful:++  rg "RealSrc(Loc|Span).*?Nothing"++For example, it is not uncommon to whip up source locations for e.g. error+messages, constructing a SrcSpan without a BufSpan.+-}+ instance ToJson SrcSpan where   json (UnhelpfulSpan {} ) = JSNull --JSObject [( "type", "unhelpful")]-  json (RealSrcSpan rss)  = json rss+  json (RealSrcSpan rss _) = json rss  instance ToJson RealSrcSpan where   json (RealSrcSpan'{..}) = JSObject [ ("file", JSString (unpackFS srcSpanFile))@@ -285,7 +356,7 @@ -- | Create a 'SrcSpan' corresponding to a single point srcLocSpan :: SrcLoc -> SrcSpan srcLocSpan (UnhelpfulLoc str) = UnhelpfulSpan str-srcLocSpan (RealSrcLoc l) = RealSrcSpan (realSrcLocSpan l)+srcLocSpan (RealSrcLoc l mb) = RealSrcSpan (realSrcLocSpan l) (fmap (\b -> BufSpan b b) mb)  realSrcLocSpan :: RealSrcLoc -> RealSrcSpan realSrcLocSpan (SrcLoc file line col) = RealSrcSpan' file line col line col@@ -314,17 +385,17 @@ mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan mkSrcSpan (UnhelpfulLoc str) _ = UnhelpfulSpan str mkSrcSpan _ (UnhelpfulLoc str) = UnhelpfulSpan str-mkSrcSpan (RealSrcLoc loc1) (RealSrcLoc loc2)-    = RealSrcSpan (mkRealSrcSpan loc1 loc2)+mkSrcSpan (RealSrcLoc loc1 mbpos1) (RealSrcLoc loc2 mbpos2)+    = RealSrcSpan (mkRealSrcSpan loc1 loc2) (liftA2 BufSpan mbpos1 mbpos2)  -- | Combines two 'SrcSpan' into one that spans at least all the characters -- within both spans. Returns UnhelpfulSpan if the files differ. combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan combineSrcSpans (UnhelpfulSpan _) r = r -- this seems more useful combineSrcSpans l (UnhelpfulSpan _) = l-combineSrcSpans (RealSrcSpan span1) (RealSrcSpan span2)+combineSrcSpans (RealSrcSpan span1 mbspan1) (RealSrcSpan span2 mbspan2)   | srcSpanFile span1 == srcSpanFile span2-      = RealSrcSpan (combineRealSrcSpans span1 span2)+      = RealSrcSpan (combineRealSrcSpans span1 span2) (liftA2 combineBufSpans mbspan1 mbspan2)   | otherwise = UnhelpfulSpan (fsLit "<combineSrcSpans: files differ>")  -- | Combines two 'SrcSpan' into one that spans at least all the characters@@ -339,13 +410,25 @@                                   (srcSpanEndLine span2, srcSpanEndCol span2)     file = srcSpanFile span1 +combineBufSpans :: BufSpan -> BufSpan -> BufSpan+combineBufSpans span1 span2 = BufSpan start end+  where+    start = min (bufSpanStart span1) (bufSpanStart span2)+    end   = max (bufSpanEnd   span1) (bufSpanEnd   span2)++ -- | Convert a SrcSpan into one that represents only its first character srcSpanFirstCharacter :: SrcSpan -> SrcSpan srcSpanFirstCharacter l@(UnhelpfulSpan {}) = l-srcSpanFirstCharacter (RealSrcSpan span) = RealSrcSpan $ mkRealSrcSpan loc1 loc2+srcSpanFirstCharacter (RealSrcSpan span mbspan) =+    RealSrcSpan (mkRealSrcSpan loc1 loc2) (fmap mkBufSpan mbspan)   where     loc1@(SrcLoc f l c) = realSrcSpanStart span     loc2 = SrcLoc f l (c+1)+    mkBufSpan bspan =+      let bpos1@(BufPos i) = bufSpanStart bspan+          bpos2 = BufPos (i+1)+      in BufSpan bpos1 bpos2  {- ************************************************************************@@ -357,13 +440,13 @@  -- | Test if a 'SrcSpan' is "good", i.e. has precise location information isGoodSrcSpan :: SrcSpan -> Bool-isGoodSrcSpan (RealSrcSpan _) = True+isGoodSrcSpan (RealSrcSpan _ _) = True isGoodSrcSpan (UnhelpfulSpan _) = False  isOneLineSpan :: SrcSpan -> Bool -- ^ True if the span is known to straddle only one line. -- For "bad" 'SrcSpan', it returns False-isOneLineSpan (RealSrcSpan s) = srcSpanStartLine s == srcSpanEndLine s+isOneLineSpan (RealSrcSpan s _) = srcSpanStartLine s == srcSpanEndLine s isOneLineSpan (UnhelpfulSpan _) = False  -- | Tests whether the first span "contains" the other span, meaning@@ -406,12 +489,12 @@ -- | Returns the location at the start of the 'SrcSpan' or a "bad" 'SrcSpan' if that is unavailable srcSpanStart :: SrcSpan -> SrcLoc srcSpanStart (UnhelpfulSpan str) = UnhelpfulLoc str-srcSpanStart (RealSrcSpan s) = RealSrcLoc (realSrcSpanStart s)+srcSpanStart (RealSrcSpan s b) = RealSrcLoc (realSrcSpanStart s) (fmap bufSpanStart b)  -- | Returns the location at the end of the 'SrcSpan' or a "bad" 'SrcSpan' if that is unavailable srcSpanEnd :: SrcSpan -> SrcLoc srcSpanEnd (UnhelpfulSpan str) = UnhelpfulLoc str-srcSpanEnd (RealSrcSpan s) = RealSrcLoc (realSrcSpanEnd s)+srcSpanEnd (RealSrcSpan s b) = RealSrcLoc (realSrcSpanEnd s) (fmap bufSpanEnd b)  realSrcSpanStart :: RealSrcSpan -> RealSrcLoc realSrcSpanStart s = mkRealSrcLoc (srcSpanFile s)@@ -425,7 +508,7 @@  -- | Obtains the filename for a 'SrcSpan' if it is "good" srcSpanFileName_maybe :: SrcSpan -> Maybe FastString-srcSpanFileName_maybe (RealSrcSpan s)   = Just (srcSpanFile s)+srcSpanFileName_maybe (RealSrcSpan s _) = Just (srcSpanFile s) srcSpanFileName_maybe (UnhelpfulSpan _) = Nothing  {-@@ -487,7 +570,7 @@  pprUserSpan :: Bool -> SrcSpan -> SDoc pprUserSpan _         (UnhelpfulSpan s) = ftext s-pprUserSpan show_path (RealSrcSpan s)   = pprUserRealSpan show_path s+pprUserSpan show_path (RealSrcSpan s _) = pprUserRealSpan show_path s  pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc pprUserRealSpan show_path span@(RealSrcSpan' src_path line col _ _)@@ -578,29 +661,43 @@ ************************************************************************ -} --- | Alternative strategies for ordering 'SrcSpan's-leftmost_smallest, leftmost_largest, rightmost :: SrcSpan -> SrcSpan -> Ordering-rightmost            = flip compare-leftmost_smallest    = compare-leftmost_largest a b = (srcSpanStart a `compare` srcSpanStart b)-                                `thenCmp`-                       (srcSpanEnd b `compare` srcSpanEnd a)+-- | Strategies for ordering 'SrcSpan's+leftmost_smallest, leftmost_largest, rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering+rightmost_smallest = compareSrcSpanBy (flip compare)+leftmost_smallest = compareSrcSpanBy compare+leftmost_largest = compareSrcSpanBy $ \a b ->+  (realSrcSpanStart a `compare` realSrcSpanStart b)+    `thenCmp`+  (realSrcSpanEnd b `compare` realSrcSpanEnd a) +compareSrcSpanBy :: (RealSrcSpan -> RealSrcSpan -> Ordering) -> SrcSpan -> SrcSpan -> Ordering+compareSrcSpanBy cmp (RealSrcSpan a _) (RealSrcSpan b _) = cmp a b+compareSrcSpanBy _   (RealSrcSpan _ _) (UnhelpfulSpan _) = LT+compareSrcSpanBy _   (UnhelpfulSpan _) (RealSrcSpan _ _) = GT+compareSrcSpanBy _   (UnhelpfulSpan _) (UnhelpfulSpan _) = EQ+ -- | Determines whether a span encloses a given line and column index spans :: SrcSpan -> (Int, Int) -> Bool spans (UnhelpfulSpan _) _ = panic "spans UnhelpfulSpan"-spans (RealSrcSpan span) (l,c) = realSrcSpanStart span <= loc && loc <= realSrcSpanEnd span+spans (RealSrcSpan span _) (l,c) = realSrcSpanStart span <= loc && loc <= realSrcSpanEnd span    where loc = mkRealSrcLoc (srcSpanFile span) l c  -- | Determines whether a span is enclosed by another one isSubspanOf :: SrcSpan -- ^ The span that may be enclosed by the other             -> SrcSpan -- ^ The span it may be enclosed by             -> Bool-isSubspanOf src parent-    | srcSpanFileName_maybe parent /= srcSpanFileName_maybe src = False-    | otherwise = srcSpanStart parent <= srcSpanStart src &&-                  srcSpanEnd parent   >= srcSpanEnd src+isSubspanOf (RealSrcSpan src _) (RealSrcSpan parent _) = isRealSubspanOf src parent+isSubspanOf _ _ = False +-- | Determines whether a span is enclosed by another one+isRealSubspanOf :: RealSrcSpan -- ^ The span that may be enclosed by the other+                -> RealSrcSpan -- ^ The span it may be enclosed by+                -> Bool+isRealSubspanOf src parent+    | srcSpanFile parent /= srcSpanFile src = False+    | otherwise = realSrcSpanStart parent <= realSrcSpanStart src &&+                  realSrcSpanEnd parent   >= realSrcSpanEnd src+ liftL :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) liftL f (L loc a) = do   a' <- f a@@ -611,3 +708,34 @@  unRealSrcSpan :: RealLocated a -> a unRealSrcSpan  (L _ e) = e+++-- | A location as produced by the parser. Consists of two components:+--+-- * The location in the file, adjusted for #line and {-# LINE ... #-} pragmas (RealSrcLoc)+-- * The location in the string buffer (BufPos) with monotonicity guarantees (see #17632)+data PsLoc+  = PsLoc { psRealLoc :: !RealSrcLoc, psBufPos :: !BufPos }+  deriving (Eq, Ord, Show)++data PsSpan+  = PsSpan { psRealSpan :: !RealSrcSpan, psBufSpan :: !BufSpan }+  deriving (Eq, Ord, Show)++type PsLocated = GenLocated PsSpan++advancePsLoc :: PsLoc -> Char -> PsLoc+advancePsLoc (PsLoc real_loc buf_loc) c =+  PsLoc (advanceSrcLoc real_loc c) (advanceBufPos buf_loc)++mkPsSpan :: PsLoc -> PsLoc -> PsSpan+mkPsSpan (PsLoc r1 b1) (PsLoc r2 b2) = PsSpan (mkRealSrcSpan r1 r2) (BufSpan b1 b2)++psSpanStart :: PsSpan -> PsLoc+psSpanStart (PsSpan r b) = PsLoc (realSrcSpanStart r) (bufSpanStart b)++psSpanEnd :: PsSpan -> PsLoc+psSpanEnd (PsSpan r b) = PsLoc (realSrcSpanEnd r) (bufSpanEnd b)++mkSrcSpanPs :: PsSpan -> SrcSpan+mkSrcSpanPs (PsSpan r b) = RealSrcSpan r (Just b)

compiler/basicTypes/Unique.hs view

@@ -394,12 +394,6 @@ tyConRepNameUnique :: Unique -> Unique tyConRepNameUnique  u = incrUnique u --- Data constructor keys occupy *two* slots.  The first is used for the--- data constructor itself and its wrapper function (the function that--- evaluates arguments as necessary and calls the worker). The second is--- used for the worker function (the function that builds the constructor--- representation).- -------------------------------------------------- -- Wired-in data constructor keys occupy *three* slots: --    * u: the DataCon itself

compiler/basicTypes/Var.hs view

@@ -102,7 +102,6 @@               , mkUniqueGrimily, nonDetCmpUnique ) import Util import Binary-import DynFlags import Outputable  import Data.Data@@ -300,9 +299,9 @@ -}  instance Outputable Var where-  ppr var = sdocWithDynFlags $ \dflags ->+  ppr var = sdocOption sdocSuppressVarKinds $ \supp_var_kinds ->             getPprStyle $ \ppr_style ->-            if |  debugStyle ppr_style && (not (gopt Opt_SuppressVarKinds dflags))+            if |  debugStyle ppr_style && (not supp_var_kinds)                  -> parens (ppr (varName var) <+> ppr_debug var ppr_style <+>                           dcolon <+> pprKind (tyVarKind var))                |  otherwise

compiler/basicTypes/VarSet.hs view

@@ -23,6 +23,7 @@         sizeVarSet, seqVarSet,         elemVarSetByKey, partitionVarSet,         pluralVarSet, pprVarSet,+        nonDetFoldVarSet,          -- * Deterministic Var set types         DVarSet, DIdSet, DTyVarSet, DTyCoVarSet,@@ -150,6 +151,9 @@  mapVarSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b mapVarSet = mapUniqSet++nonDetFoldVarSet :: (Var -> a -> a) -> a -> VarSet -> a+nonDetFoldVarSet = nonDetFoldUniqSet  fixVarSet :: (VarSet -> VarSet)   -- Map the current set to a new set           -> VarSet -> VarSet

− compiler/coreSyn/CoreArity.hs

@@ -1,1210 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998---        Arity and eta expansion--}--{-# LANGUAGE CPP #-}--{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}---- | Arity and eta expansion-module CoreArity (-        manifestArity, joinRhsArity, exprArity, typeArity,-        exprEtaExpandArity, findRhsArity, etaExpand,-        etaExpandToJoinPoint, etaExpandToJoinPointRule,-        exprBotStrictness_maybe-    ) where--#include "HsVersions.h"--import GhcPrelude--import CoreSyn-import CoreFVs-import CoreUtils-import CoreSubst-import Demand-import Var-import VarEnv-import Id-import Type-import TyCon    ( initRecTc, checkRecTc )-import Predicate ( isDictTy )-import Coercion-import BasicTypes-import Unique-import DynFlags ( DynFlags, GeneralFlag(..), gopt )-import Outputable-import FastString-import Util     ( debugIsOn )--{--************************************************************************-*                                                                      *-              manifestArity and exprArity-*                                                                      *-************************************************************************--exprArity is a cheap-and-cheerful version of exprEtaExpandArity.-It tells how many things the expression can be applied to before doing-any work.  It doesn't look inside cases, lets, etc.  The idea is that-exprEtaExpandArity will do the hard work, leaving something that's easy-for exprArity to grapple with.  In particular, Simplify uses exprArity to-compute the ArityInfo for the Id.--Originally I thought that it was enough just to look for top-level lambdas, but-it isn't.  I've seen this--        foo = PrelBase.timesInt--We want foo to get arity 2 even though the eta-expander will leave it-unchanged, in the expectation that it'll be inlined.  But occasionally it-isn't, because foo is blacklisted (used in a rule).--Similarly, see the ok_note check in exprEtaExpandArity.  So-        f = __inline_me (\x -> e)-won't be eta-expanded.--And in any case it seems more robust to have exprArity be a bit more intelligent.-But note that   (\x y z -> f x y z)-should have arity 3, regardless of f's arity.--}--manifestArity :: CoreExpr -> Arity--- ^ manifestArity sees how many leading value lambdas there are,---   after looking through casts-manifestArity (Lam v e) | isId v        = 1 + manifestArity e-                        | otherwise     = manifestArity e-manifestArity (Tick t e) | not (tickishIsCode t) =  manifestArity e-manifestArity (Cast e _)                = manifestArity e-manifestArity _                         = 0--joinRhsArity :: CoreExpr -> JoinArity--- Join points are supposed to have manifestly-visible--- lambdas at the top: no ticks, no casts, nothing--- Moreover, type lambdas count in JoinArity-joinRhsArity (Lam _ e) = 1 + joinRhsArity e-joinRhsArity _         = 0-------------------exprArity :: CoreExpr -> Arity--- ^ An approximate, fast, version of 'exprEtaExpandArity'-exprArity e = go e-  where-    go (Var v)                     = idArity v-    go (Lam x e) | isId x          = go e + 1-                 | otherwise       = go e-    go (Tick t e) | not (tickishIsCode t) = go e-    go (Cast e co)                 = trim_arity (go e) (coercionRKind co)-                                        -- Note [exprArity invariant]-    go (App e (Type _))            = go e-    go (App f a) | exprIsTrivial a = (go f - 1) `max` 0-        -- See Note [exprArity for applications]-        -- NB: coercions count as a value argument--    go _                           = 0--    trim_arity :: Arity -> Type -> Arity-    trim_arity arity ty = arity `min` length (typeArity ty)------------------typeArity :: Type -> [OneShotInfo]--- How many value arrows are visible in the type?--- We look through foralls, and newtypes--- See Note [exprArity invariant]-typeArity ty-  = go initRecTc ty-  where-    go rec_nts ty-      | Just (_, ty')  <- splitForAllTy_maybe ty-      = go rec_nts ty'--      | Just (arg,res) <- splitFunTy_maybe ty-      = typeOneShot arg : go rec_nts res--      | Just (tc,tys) <- splitTyConApp_maybe ty-      , Just (ty', _) <- instNewTyCon_maybe tc tys-      , Just rec_nts' <- checkRecTc rec_nts tc  -- See Note [Expanding newtypes]-                                                -- in TyCon---   , not (isClassTyCon tc)    -- Do not eta-expand through newtype classes---                              -- See Note [Newtype classes and eta expansion]---                              (no longer required)-      = go rec_nts' ty'-        -- Important to look through non-recursive newtypes, so that, eg-        --      (f x)   where f has arity 2, f :: Int -> IO ()-        -- Here we want to get arity 1 for the result!-        ---        -- AND through a layer of recursive newtypes-        -- e.g. newtype Stream m a b = Stream (m (Either b (a, Stream m a b)))--      | otherwise-      = []------------------exprBotStrictness_maybe :: CoreExpr -> Maybe (Arity, StrictSig)--- A cheap and cheerful function that identifies bottoming functions--- and gives them a suitable strictness signatures.  It's used during--- float-out-exprBotStrictness_maybe e-  = case getBotArity (arityType env e) of-        Nothing -> Nothing-        Just ar -> Just (ar, sig ar)-  where-    env    = AE { ae_ped_bot = True, ae_cheap_fn = \ _ _ -> False }-    sig ar = mkClosedStrictSig (replicate ar topDmd) botRes--{--Note [exprArity invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~-exprArity has the following invariants:--  (1) If typeArity (exprType e) = n,-      then manifestArity (etaExpand e n) = n--      That is, etaExpand can always expand as much as typeArity says-      So the case analysis in etaExpand and in typeArity must match--  (2) exprArity e <= typeArity (exprType e)--  (3) Hence if (exprArity e) = n, then manifestArity (etaExpand e n) = n--      That is, if exprArity says "the arity is n" then etaExpand really-      can get "n" manifest lambdas to the top.--Why is this important?  Because-  - In GHC.Iface.Tidy we use exprArity to fix the *final arity* of-    each top-level Id, and in-  - In CorePrep we use etaExpand on each rhs, so that the visible lambdas-    actually match that arity, which in turn means-    that the StgRhs has the right number of lambdas--An alternative would be to do the eta-expansion in GHC.Iface.Tidy, at least-for top-level bindings, in which case we would not need the trim_arity-in exprArity.  That is a less local change, so I'm going to leave it for today!--Note [Newtype classes and eta expansion]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-    NB: this nasty special case is no longer required, because-    for newtype classes we don't use the class-op rule mechanism-    at all.  See Note [Single-method classes] in TcInstDcls. SLPJ May 2013---------- Old out of date comments, just for interest ------------We have to be careful when eta-expanding through newtypes.  In general-it's a good idea, but annoyingly it interacts badly with the class-op-rule mechanism.  Consider--   class C a where { op :: a -> a }-   instance C b => C [b] where-     op x = ...--These translate to--   co :: forall a. (a->a) ~ C a--   $copList :: C b -> [b] -> [b]-   $copList d x = ...--   $dfList :: C b -> C [b]-   {-# DFunUnfolding = [$copList] #-}-   $dfList d = $copList d |> co@[b]--Now suppose we have:--   dCInt :: C Int--   blah :: [Int] -> [Int]-   blah = op ($dfList dCInt)--Now we want the built-in op/$dfList rule will fire to give-   blah = $copList dCInt--But with eta-expansion 'blah' might (and in #3772, which is-slightly more complicated, does) turn into--   blah = op (\eta. ($dfList dCInt |> sym co) eta)--and now it is *much* harder for the op/$dfList rule to fire, because-exprIsConApp_maybe won't hold of the argument to op.  I considered-trying to *make* it hold, but it's tricky and I gave up.--The test simplCore/should_compile/T3722 is an excellent example.--------- End of old out of date comments, just for interest --------------Note [exprArity for applications]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we come to an application we check that the arg is trivial.-   eg  f (fac x) does not have arity 2,-                 even if f has arity 3!--* We require that is trivial rather merely cheap.  Suppose f has arity 2.-  Then    f (Just y)-  has arity 0, because if we gave it arity 1 and then inlined f we'd get-          let v = Just y in \w. <f-body>-  which has arity 0.  And we try to maintain the invariant that we don't-  have arity decreases.--*  The `max 0` is important!  (\x y -> f x) has arity 2, even if f is-   unknown, hence arity 0---************************************************************************-*                                                                      *-           Computing the "arity" of an expression-*                                                                      *-************************************************************************--Note [Definition of arity]-~~~~~~~~~~~~~~~~~~~~~~~~~~-The "arity" of an expression 'e' is n if-   applying 'e' to *fewer* than n *value* arguments-   converges rapidly--Or, to put it another way--   there is no work lost in duplicating the partial-   application (e x1 .. x(n-1))--In the divergent case, no work is lost by duplicating because if the thing-is evaluated once, that's the end of the program.--Or, to put it another way, in any context C--   C[ (\x1 .. xn. e x1 .. xn) ]-         is as efficient as-   C[ e ]--It's all a bit more subtle than it looks:--Note [One-shot lambdas]-~~~~~~~~~~~~~~~~~~~~~~~-Consider one-shot lambdas-                let x = expensive in \y z -> E-We want this to have arity 1 if the \y-abstraction is a 1-shot lambda.--Note [Dealing with bottom]-~~~~~~~~~~~~~~~~~~~~~~~~~~-A Big Deal with computing arities is expressions like--   f = \x -> case x of-               True  -> \s -> e1-               False -> \s -> e2--This happens all the time when f :: Bool -> IO ()-In this case we do eta-expand, in order to get that \s to the-top, and give f arity 2.--This isn't really right in the presence of seq.  Consider-        (f bot) `seq` 1--This should diverge!  But if we eta-expand, it won't.  We ignore this-"problem" (unless -fpedantic-bottoms is on), because being scrupulous-would lose an important transformation for many programs. (See-#5587 for an example.)--Consider also-        f = \x -> error "foo"-Here, arity 1 is fine.  But if it is-        f = \x -> case x of-                        True  -> error "foo"-                        False -> \y -> x+y-then we want to get arity 2.  Technically, this isn't quite right, because-        (f True) `seq` 1-should diverge, but it'll converge if we eta-expand f.  Nevertheless, we-do so; it improves some programs significantly, and increasing convergence-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 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-       case undefined of { (a,b) -> \y -> e }-     This showed up in #5557-- (2) Do NOT move a lambda outside a case if all the branches of-     the case are known to return bottom.-        case x of { (a,b) -> \y -> error "urk" }-     This case is less important, but the idea is that if the fn is-     going to diverge eventually anyway then getting the best arity-     isn't an issue, so we might as well play safe-- (3) Do NOT move a lambda outside a case unless-     (a) The scrutinee is ok-for-speculation, or-     (b) more liberally: the scrutinee is cheap (e.g. a variable), and-         -fpedantic-bottoms is not enforced (see #2915 for an example)--Of course both (1) and (2) are readily defeated by disguising the bottoms.--4. Note [Newtype arity]-~~~~~~~~~~~~~~~~~~~~~~~~-Non-recursive newtypes are transparent, and should not get in the way.-We do (currently) eta-expand recursive newtypes too.  So if we have, say--        newtype T = MkT ([T] -> Int)--Suppose we have-        e = coerce T f-where f has arity 1.  Then: etaExpandArity e = 1;-that is, etaExpandArity looks through the coerce.--When we eta-expand e to arity 1: eta_expand 1 e T-we want to get:                  coerce T (\x::[T] -> (coerce ([T]->Int) e) x)--  HOWEVER, note that if you use coerce bogusly you can ge-        coerce Int negate-  And since negate has arity 2, you might try to eta expand.  But you can't-  decompose Int to a function type.   Hence the final case in eta_expand.--Note [The state-transformer hack]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose we have-        f = e-where e has arity n.  Then, if we know from the context that f has-a usage type like-        t1 -> ... -> tn -1-> t(n+1) -1-> ... -1-> tm -> ...-then we can expand the arity to m.  This usage type says that-any application (x e1 .. en) will be applied to uniquely to (m-n) more args-Consider f = \x. let y = <expensive>-                 in case x of-                      True  -> foo-                      False -> \(s:RealWorld) -> e-where foo has arity 1.  Then we want the state hack to-apply to foo too, so we can eta expand the case.--Then we expect that if f is applied to one arg, it'll be applied to two-(that's the hack -- we don't really know, and sometimes it's false)-See also Id.isOneShotBndr.--Note [State hack and bottoming functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's a terrible idea to use the state hack on a bottoming function.-Here's what happens (#2861):--  f :: String -> IO T-  f = \p. error "..."--Eta-expand, using the state hack:--  f = \p. (\s. ((error "...") |> g1) s) |> g2-  g1 :: IO T ~ (S -> (S,T))-  g2 :: (S -> (S,T)) ~ IO T--Extrude the g2--  f' = \p. \s. ((error "...") |> g1) s-  f = f' |> (String -> g2)--Discard args for bottomming function--  f' = \p. \s. ((error "...") |> g1 |> g3-  g3 :: (S -> (S,T)) ~ (S,T)--Extrude g1.g3--  f'' = \p. \s. (error "...")-  f' = f'' |> (String -> S -> g1.g3)--And now we can repeat the whole loop.  Aargh!  The bug is in applying the-state hack to a function which then swallows the argument.--This arose in another guise in #3959.  Here we had--     catch# (throw exn >> return ())--Note that (throw :: forall a e. Exn e => e -> a) is called with [a = IO ()].-After inlining (>>) we get--     catch# (\_. throw {IO ()} exn)--We must *not* eta-expand to--     catch# (\_ _. throw {...} exn)--because 'catch#' expects to get a (# _,_ #) after applying its argument to-a State#, not another function!--In short, we use the state hack to allow us to push let inside a lambda,-but not to introduce a new lambda.---Note [ArityType]-~~~~~~~~~~~~~~~~-ArityType is the result of a compositional analysis on expressions,-from which we can decide the real arity of the expression (extracted-with function exprEtaExpandArity).--Here is what the fields mean. If an arbitrary expression 'f' has-ArityType 'at', then-- * If at = ABot n, then (f x1..xn) definitely diverges. Partial-   applications to fewer than n args may *or may not* diverge.--   We allow ourselves to eta-expand bottoming functions, even-   if doing so may lose some `seq` sharing,-       let x = <expensive> in \y. error (g x y)-       ==> \y. let x = <expensive> in error (g x y)-- * If at = ATop as, and n=length as,-   then expanding 'f' to (\x1..xn. f x1 .. xn) loses no sharing,-   assuming the calls of f respect the one-shot-ness of-   its definition.--   NB 'f' is an arbitrary expression, eg (f = g e1 e2).  This 'f'-   can have ArityType as ATop, with length as > 0, only if e1 e2 are-   themselves.-- * In both cases, f, (f x1), ... (f x1 ... f(n-1)) are definitely-   really functions, or bottom, but *not* casts from a data type, in-   at least one case branch.  (If it's a function in one case branch but-   an unsafe cast from a data type in another, the program is bogus.)-   So eta expansion is dynamically ok; see Note [State hack and-   bottoming functions], the part about catch#--Example:-      f = \x\y. let v = <expensive> in-          \s(one-shot) \t(one-shot). blah-      'f' has ArityType [ManyShot,ManyShot,OneShot,OneShot]-      The one-shot-ness means we can, in effect, push that-      'let' inside the \st.---Suppose f = \xy. x+y-Then  f             :: AT [False,False] ATop-      f v           :: AT [False]       ATop-      f <expensive> :: AT []            ATop---------------------- Main arity code ------------------------------}---- See Note [ArityType]-data ArityType = ATop [OneShotInfo] | ABot Arity-     -- 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---- ^ The Arity returned is the number of value args the--- expression can be applied to without doing much work-exprEtaExpandArity :: DynFlags -> CoreExpr -> Arity--- exprEtaExpandArity is used when eta expanding---      e  ==>  \xy -> e x y-exprEtaExpandArity dflags e-  = case (arityType env e) of-      ATop oss -> length oss-      ABot n   -> n-  where-    env = AE { ae_cheap_fn = mk_cheap_fn dflags isCheapApp-             , ae_ped_bot  = gopt Opt_PedanticBottoms dflags }--getBotArity :: ArityType -> Maybe Arity--- Arity of a divergent function-getBotArity (ABot n) = Just n-getBotArity _        = Nothing--mk_cheap_fn :: DynFlags -> CheapAppFun -> CheapFun-mk_cheap_fn dflags cheap_app-  | not (gopt Opt_DictsCheap dflags)-  = \e _     -> exprIsCheapX cheap_app e-  | otherwise-  = \e mb_ty -> exprIsCheapX cheap_app e-             || case mb_ty of-                  Nothing -> False-                  Just ty -> isDictTy ty--------------------------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 (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, 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 )-#if defined(DEBUG)-                    pprTrace "Exciting arity"-                       (vcat [ ppr bndr <+> ppr cur_arity <+> ppr new_arity-                             , ppr rhs])-#endif-                    go new_info-      where-        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--    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]-~~~~~~~~~~~~~~~~~~~~~-The motivating example for arity analysis is this:--  f = \x. let g = f (x+1)-          in \y. ...g...--What arity does f have?  Really it should have arity 2, but a naive-look at the RHS won't see that.  You need a fixpoint analysis which-says it has arity "infinity" the first time round.--This example happens a lot; it first showed up in Andy Gill's thesis,-fifteen years ago!  It also shows up in the code for 'rnf' on lists-in #4138.--The analysis is easy to achieve because exprEtaExpandArity takes an-argument-     type CheapFun = CoreExpr -> Maybe Type -> Bool-used to decide if an expression is cheap enough to push inside a-lambda.  And exprIsCheapX in turn takes an argument-     type CheapAppFun = Id -> Int -> Bool-which tells when an application is cheap. This makes it easy to-write the analysis loop.--The analysis is cheap-and-cheerful because it doesn't deal with-mutual recursion.  But the self-recursive case is the important one.---Note [Eta expanding through dictionaries]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If the experimental -fdicts-cheap flag is on, we eta-expand through-dictionary bindings.  This improves arities. Thereby, it also-means that full laziness is less prone to floating out the-application of a function to its dictionary arguments, which-can thereby lose opportunities for fusion.  Example:-        foo :: Ord a => a -> ...-     foo = /\a \(d:Ord a). let d' = ...d... in \(x:a). ....-        -- So foo has arity 1--     f = \x. foo dInt $ bar x--The (foo DInt) is floated out, and makes ineffective a RULE-     foo (bar x) = ...--One could go further and make exprIsCheap reply True to any-dictionary-typed expression, but that's more work.--Note [Eta expanding thunks]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-We don't eta-expand-   * Trivial RHSs     x = y-   * PAPs             x = map g-   * Thunks           f = case y of p -> \x -> blah--When we see-     f = case y of p -> \x -> blah-should we eta-expand it? Well, if 'x' is a one-shot state token-then 'yes' because 'f' will only be applied once.  But otherwise-we (conservatively) say no.  My main reason is to avoid expanding-PAPSs-        f = g d  ==>  f = \x. g d x-because that might in turn make g inline (if it has an inline pragma),-which we might not want.  After all, INLINE pragmas say "inline only-when saturated" so we don't want to be too gung-ho about saturating!--}--arityLam :: Id -> ArityType -> ArityType-arityLam id (ATop as) = ATop (idStateHackOneShotInfo id : as)-arityLam _  (ABot n)  = ABot (n+1)--floatIn :: Bool -> ArityType -> ArityType--- We have something like (let x = E in b),--- where b has the given arity type.-floatIn _     (ABot n)  = ABot n-floatIn True  (ATop as) = ATop as-floatIn False (ATop as) = ATop (takeWhile isOneShotInfo as)-   -- If E is not cheap, keep arity only for one-shots--arityApp :: ArityType -> Bool -> ArityType--- Processing (fun arg) where at is the ArityType of fun,--- Knock off an argument and behave like 'let'-arityApp (ABot 0)      _     = ABot 0-arityApp (ABot n)      _     = ABot (n-1)-arityApp (ATop [])     _     = ATop []-arityApp (ATop (_:as)) cheap = floatIn cheap (ATop as)--andArityType :: ArityType -> ArityType -> ArityType   -- Used for branches of a 'case'-andArityType (ABot n1) (ABot n2)  = ABot (n1 `max` n2) -- Note [ABot branches: use max]-andArityType (ATop as)  (ABot _)  = ATop as-andArityType (ABot _)   (ATop bs) = ATop bs-andArityType (ATop as)  (ATop bs) = ATop (as `combine` bs)-  where      -- See Note [Combining case branches]-    combine (a:as) (b:bs) = (a `bestOneShot` b) : combine as bs-    combine []     bs     = takeWhile isOneShotInfo bs-    combine as     []     = takeWhile isOneShotInfo as--{- Note [ABot branches: use max]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider   case x of-             True  -> \x.  error "urk"-             False -> \xy. error "urk2"--Remember: ABot n means "if you apply to n args, it'll definitely diverge".-So we need (ABot 2) for the whole thing, the /max/ of the ABot arities.--Note [Combining case branches]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-  go = \x. let z = go e0-               go2 = \x. case x of-                           True  -> z-                           False -> \s(one-shot). e1-           in go2 x-We *really* want to eta-expand go and go2.-When combining the branches of the case we have-     ATop [] `andAT` ATop [OneShotLam]-and we want to get ATop [OneShotLam].  But if the inner-lambda wasn't one-shot we don't want to do this.-(We need a proper arity analysis to justify that.)--So we combine the best of the two branches, on the (slightly dodgy)-basis that if we know one branch is one-shot, then they all must be.--Note [Arity trimming]-~~~~~~~~~~~~~~~~~~~~~-Consider ((\x y. blah) |> co), where co :: (Int->Int->Int) ~ (Int -> F a) , and-F is some type family.--Because of Note [exprArity invariant], item (2), we must return with arity at-most 1, because typeArity (Int -> F a) = 1.  So we have to trim the result of-calling arityType on (\x y. blah).  Failing to do so, and hence breaking the-exprArity invariant, led to #5441.--How to trim?  For ATop, it's easy.  But we must take great care with ABot.-Suppose the expression was (\x y. error "urk"), we'll get (ABot 2).  We-absolutely must not trim that to (ABot 1), because that claims that-((\x y. error "urk") |> co) diverges when given one argument, which it-absolutely does not. And Bad Things happen if we think something returns bottom-when it doesn't (#16066).--So, do not reduce the 'n' in (ABot n); rather, switch (conservatively) to ATop.--Historical note: long ago, we unconditionally switched to ATop when we-encountered a cast, but that is far too conservative: see #5475--}------------------------------type CheapFun = CoreExpr -> Maybe Type -> Bool-        -- How to decide if an expression is cheap-        -- If the Maybe is Just, the type is the type-        -- of the expression; Nothing means "don't know"--data ArityEnv-  = AE { ae_cheap_fn :: CheapFun-       , ae_ped_bot  :: Bool       -- True <=> be pedantic about bottoms-  }--arityType :: ArityEnv -> CoreExpr -> ArityType--arityType env (Cast e co)-  = case arityType env e of-      ATop os -> ATop (take co_arity os)-      -- See Note [Arity trimming]-      ABot n | co_arity < n -> ATop (replicate co_arity noOneShotInfo)-             | otherwise    -> ABot n-  where-    co_arity = length (typeArity (coercionRKind co))-    -- See Note [exprArity invariant] (2); must be true of-    -- arityType too, since that is how we compute the arity-    -- of variables, and they in turn affect result of exprArity-    -- #5441 is a nice demo-    -- However, do make sure that ATop -> ATop and ABot -> ABot!-    --   Casts don't affect that part. Getting this wrong provoked #5475--arityType _ (Var v)-  | strict_sig <- idStrictness v-  , not $ isTopSig strict_sig-  , (ds, res) <- splitStrictSig strict_sig-  , let arity = length ds-  = if isBotRes res then ABot arity-                    else ATop (take arity one_shots)-  | otherwise-  = ATop (take (idArity v) one_shots)-  where-    one_shots :: [OneShotInfo]  -- One-shot-ness derived from the type-    one_shots = typeArity (idType v)--        -- Lambdas; increase arity-arityType env (Lam x e)-  | isId x    = arityLam x (arityType env e)-  | otherwise = arityType env e--        -- Applications; decrease arity, except for types-arityType env (App fun (Type _))-   = arityType env fun-arityType env (App fun arg )-   = arityApp (arityType env fun) (ae_cheap_fn env arg Nothing)--        -- Case/Let; keep arity if either the expression is cheap-        -- or it's a 1-shot lambda-        -- The former is not really right for Haskell-        --      f x = case x of { (a,b) -> \y. e }-        --  ===>-        --      f x y = case x of { (a,b) -> e }-        -- The difference is observable using 'seq'-        ---arityType env (Case scrut _ _ alts)-  | exprIsBottom scrut || null alts-  = ABot 0     -- Do not eta expand-               -- See Note [Dealing with bottom (1)]-  | otherwise-  = case alts_type of-     ABot n  | n>0       -> ATop []    -- Don't eta expand-             | otherwise -> ABot 0     -- if RHS is bottomming-                                       -- See Note [Dealing with bottom (2)]--     ATop as | not (ae_ped_bot env)    -- See Note [Dealing with bottom (3)]-             , ae_cheap_fn env scrut Nothing -> ATop as-             | exprOkForSpeculation scrut    -> ATop as-             | otherwise                     -> ATop (takeWhile isOneShotInfo as)-  where-    alts_type = foldr1 andArityType [arityType env rhs | (_,_,rhs) <- alts]--arityType env (Let b e)-  = floatIn (cheap_bind b) (arityType env e)-  where-    cheap_bind (NonRec b e) = is_cheap (b,e)-    cheap_bind (Rec prs)    = all is_cheap prs-    is_cheap (b,e) = ae_cheap_fn env e (Just (idType b))--arityType env (Tick t e)-  | not (tickishIsCode t)     = arityType env e--arityType _ _ = vanillaArityType--{--%************************************************************************-%*                                                                      *-              The main eta-expander-%*                                                                      *-%************************************************************************--We go for:-   f = \x1..xn -> N  ==>   f = \x1..xn y1..ym -> N y1..ym-                                 (n >= 0)--where (in both cases)--        * The xi can include type variables--        * The yi are all value variables--        * N is a NORMAL FORM (i.e. no redexes anywhere)-          wanting a suitable number of extra args.--The biggest reason for doing this is for cases like--        f = \x -> case x of-                    True  -> \y -> e1-                    False -> \y -> e2--Here we want to get the lambdas together.  A good example is the nofib-program fibheaps, which gets 25% more allocation if you don't do this-eta-expansion.--We may have to sandwich some coerces between the lambdas-to make the types work.   exprEtaExpandArity looks through coerces-when computing arity; and etaExpand adds the coerces as necessary when-actually computing the expansion.--Note [No crap in eta-expanded code]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The eta expander is careful not to introduce "crap".  In particular,-given a CoreExpr satisfying the 'CpeRhs' invariant (in CorePrep), it-returns a CoreExpr satisfying the same invariant. See Note [Eta-expansion and the CorePrep invariants] in CorePrep.--This means the eta-expander has to do a bit of on-the-fly-simplification but it's not too hard.  The alternative, of relying on-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 abandoning 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-        etaExpand 2 (\x -> scc "foo" e)-        = (\xy -> (scc "foo" e) y)-So the costs of evaluating 'e' (not 'e y') are attributed to "foo"--Note [Eta expansion and source notes]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-CorePrep puts floatable ticks outside of value applications, but not-type applications. As a result we might be trying to eta-expand an-expression like--  (src<...> v) @a--which we want to lead to code like--  \x -> src<...> v @a x--This means that we need to look through type applications and be ready-to re-add floats on the top.---}---- | @etaExpand n e@ returns an expression with--- the same meaning as @e@, but with arity @n@.------ Given:------ > e' = etaExpand n e------ We should have that:------ > ty = exprType e = exprType e'-etaExpand :: Arity              -- ^ Result should have this number of value args-          -> CoreExpr           -- ^ Expression to expand-          -> CoreExpr--- etaExpand arity e = res--- Then 'res' has at least 'arity' lambdas at the top------ etaExpand deals with for-alls. For example:---              etaExpand 1 E--- where  E :: forall a. a -> a--- would return---      (/\b. \y::a -> E b y)------ It deals with coerces too, though they are now rare--- so perhaps the extra code isn't worth it--etaExpand n orig_expr-  = go n orig_expr-  where-      -- Strip off existing lambdas and casts before handing off to mkEtaWW-      -- Note [Eta expansion and SCCs]-    go 0 expr = expr-    go n (Lam v body) | isTyVar v = Lam v (go n     body)-                      | otherwise = Lam v (go (n-1) body)-    go n (Cast expr co)           = Cast (go n expr) co-    go n expr-      = -- pprTrace "ee" (vcat [ppr orig_expr, ppr expr, ppr etas]) $-        retick $ etaInfoAbs etas (etaInfoApp subst' sexpr etas)-      where-          in_scope = mkInScopeSet (exprFreeVars expr)-          (in_scope', etas) = mkEtaWW n (ppr orig_expr) in_scope (exprType expr)-          subst' = mkEmptySubst in_scope'--          -- Find ticks behind type apps.-          -- See Note [Eta expansion and source notes]-          (expr', args) = collectArgs expr-          (ticks, expr'') = stripTicksTop tickishFloatable expr'-          sexpr = foldl' App expr'' args-          retick expr = foldr mkTick expr ticks--                                -- Abstraction    Application----------------data EtaInfo = EtaVar Var       -- /\a. []        [] a-                                -- \x.  []        [] x-             | EtaCo Coercion   -- [] |> sym co   [] |> co--instance Outputable EtaInfo where-   ppr (EtaVar v) = text "EtaVar" <+> ppr v-   ppr (EtaCo co) = text "EtaCo"  <+> ppr co--pushCoercion :: Coercion -> [EtaInfo] -> [EtaInfo]-pushCoercion co1 (EtaCo co2 : eis)-  | isReflCo co = eis-  | otherwise   = EtaCo co : eis-  where-    co = co1 `mkTransCo` co2--pushCoercion co eis = EtaCo co : eis-----------------etaInfoAbs :: [EtaInfo] -> CoreExpr -> CoreExpr-etaInfoAbs []               expr = expr-etaInfoAbs (EtaVar v : eis) expr = Lam v (etaInfoAbs eis expr)-etaInfoAbs (EtaCo co : eis) expr = Cast (etaInfoAbs eis expr) (mkSymCo co)-----------------etaInfoApp :: Subst -> CoreExpr -> [EtaInfo] -> CoreExpr--- (etaInfoApp s e eis) returns something equivalent to---             ((substExpr s e) `appliedto` eis)--etaInfoApp subst (Lam v1 e) (EtaVar v2 : eis)-  = etaInfoApp (CoreSubst.extendSubstWithVar subst v1 v2) e eis--etaInfoApp subst (Cast e co1) eis-  = etaInfoApp subst e (pushCoercion co' eis)-  where-    co' = CoreSubst.substCo subst co1--etaInfoApp subst (Case e b ty alts) eis-  = 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--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') = substBindSC subst b--etaInfoApp subst (Tick t e) eis-  = Tick (substTickish subst t) (etaInfoApp subst e eis)--etaInfoApp subst expr _-  | (Var fun, _) <- collectArgs expr-  , Var fun' <- lookupIdSubst (text "etaInfoApp" <+> ppr fun) subst fun-  , isJoinId fun'-  = subst_expr subst expr--etaInfoApp subst e eis-  = go (subst_expr subst e) eis-  where-    go e []                  = e-    go e (EtaVar v    : eis) = go (App e (varToCoreExpr v)) eis-    go e (EtaCo co    : eis) = go (Cast e co) eis------------------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 (coercionRKind co) eis------------------- | @mkEtaWW n _ fvs ty@ will compute the 'EtaInfo' necessary for eta-expanding--- an expression @e :: ty@ to take @n@ value arguments, where @fvs@ are the--- free variables of @e@.------ Note that this function is entirely unconcerned about cost centres and other--- semantically-irrelevant source annotations, so call sites must take care to--- preserve that info. See Note [Eta expansion and SCCs].-mkEtaWW-  :: Arity-  -- ^ How many value arguments to eta-expand-  -> SDoc-  -- ^ The pretty-printed original expression, for warnings.-  -> InScopeSet-  -- ^ A super-set of the free vars of the expression to eta-expand.-  -> Type-  -> (InScopeSet, [EtaInfo])-  -- ^ The variables in 'EtaInfo' are fresh wrt. to the incoming 'InScopeSet'.-  -- The outgoing 'InScopeSet' extends the incoming 'InScopeSet' with the-  -- fresh variables in 'EtaInfo'.--mkEtaWW orig_n ppr_orig_expr in_scope orig_ty-  = go orig_n empty_subst orig_ty []-  where-    empty_subst = mkEmptyTCvSubst in_scope--    go :: Arity              -- Number of value args to expand to-       -> TCvSubst -> Type   -- We are really looking at subst(ty)-       -> [EtaInfo]          -- Accumulating parameter-       -> (InScopeSet, [EtaInfo])-    go n subst ty eis       -- See Note [exprArity invariant]--       ----------- Done!  No more expansion needed-       | n == 0-       = (getTCvInScope subst, reverse eis)--       ----------- Forall types  (forall a. ty)-       | Just (tcv,ty') <- splitForAllTy_maybe ty-       , let (subst', tcv') = Type.substVarBndr subst tcv-       = let ((n_subst, n_tcv), n_n)-               -- We want to have at least 'n' lambdas at the top.-               -- If tcv is a tyvar, it corresponds to one Lambda (/\).-               --   And we won't reduce n.-               -- If tcv is a covar, we could eta-expand the expr with one-               --   lambda \co:ty. e co. In this case we generate a new variable-               --   of the coercion type, update the scope, and reduce n by 1.-               | isTyVar tcv = ((subst', tcv'), n)-               | otherwise   = (freshEtaId n subst' (varType tcv'), n-1)-           -- Avoid free vars of the original expression-         in go n_n n_subst ty' (EtaVar n_tcv : eis)--       ----------- Function types  (t1 -> t2)-       | Just (arg_ty, res_ty) <- splitFunTy_maybe ty-       , not (isTypeLevPoly arg_ty)-          -- See Note [Levity polymorphism invariants] in CoreSyn-          -- See also test case typecheck/should_run/EtaExpandLevPoly--       , let (subst', eta_id') = freshEtaId n subst arg_ty-           -- Avoid free vars of the original expression-       = go (n-1) subst' res_ty (EtaVar eta_id' : eis)--       ----------- Newtypes-       -- Given this:-       --      newtype T = MkT ([T] -> Int)-       -- Consider eta-expanding this-       --      eta_expand 1 e T-       -- We want to get-       --      coerce T (\x::[T] -> (coerce ([T]->Int) e) x)-       | Just (co, ty') <- topNormaliseNewType_maybe ty-       , let co' = Coercion.substCo subst co-             -- Remember to apply the substitution to co (#16979)-             -- (or we could have applied to ty, but then-             --  we'd have had to zap it for the recursive call)-       = 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-                         -- is levity-polymorphic-       = WARN( True, (ppr orig_n <+> ppr orig_ty) $$ ppr_orig_expr )-         (getTCvInScope subst, reverse eis)-        -- This *can* legitimately happen:-        -- e.g.  coerce Int (\x. x) Essentially the programmer is-        -- playing fast and loose with types (Happy does this a lot).-        -- So we simply decline to eta-expand.  Otherwise we'd end up-        -- with an explicit lambda having a non-function type--------------------- Don't use short-cutting substitution - we may be changing the types of join--- points, so applying the in-scope set is necessary--- TODO Check if we actually *are* changing any join points' types--subst_expr :: Subst -> CoreExpr -> CoreExpr-subst_expr = substExpr (text "CoreArity:substExpr")--------------------- | Split an expression into the given number of binders and a body,--- eta-expanding if necessary. Counts value *and* type binders.-etaExpandToJoinPoint :: JoinArity -> CoreExpr -> ([CoreBndr], CoreExpr)-etaExpandToJoinPoint join_arity expr-  = go join_arity [] expr-  where-    go 0 rev_bs e         = (reverse rev_bs, e)-    go n rev_bs (Lam b e) = go (n-1) (b : rev_bs) e-    go n rev_bs e         = case etaBodyForJoinPoint n e of-                              (bs, e') -> (reverse rev_bs ++ bs, e')--etaExpandToJoinPointRule :: JoinArity -> CoreRule -> CoreRule-etaExpandToJoinPointRule _ rule@(BuiltinRule {})-  = WARN(True, (sep [text "Can't eta-expand built-in rule:", ppr rule]))-      -- How did a local binding get a built-in rule anyway? Probably a plugin.-    rule-etaExpandToJoinPointRule join_arity rule@(Rule { ru_bndrs = bndrs, ru_rhs = rhs-                                               , ru_args  = args })-  | need_args == 0-  = rule-  | need_args < 0-  = pprPanic "etaExpandToJoinPointRule" (ppr join_arity $$ ppr rule)-  | otherwise-  = rule { ru_bndrs = bndrs ++ new_bndrs, ru_args = args ++ new_args-         , ru_rhs = new_rhs }-  where-    need_args = join_arity - length args-    (new_bndrs, new_rhs) = etaBodyForJoinPoint need_args rhs-    new_args = varsToCoreExprs new_bndrs---- Adds as many binders as asked for; assumes expr is not a lambda-etaBodyForJoinPoint :: Int -> CoreExpr -> ([CoreBndr], CoreExpr)-etaBodyForJoinPoint need_args body-  = go need_args (exprType body) (init_subst body) [] body-  where-    go 0 _  _     rev_bs e-      = (reverse rev_bs, e)-    go n ty subst rev_bs e-      | Just (tv, res_ty) <- splitForAllTy_maybe ty-      , let (subst', tv') = Type.substVarBndr subst tv-      = go (n-1) res_ty subst' (tv' : rev_bs) (e `App` varToCoreExpr tv')-      | Just (arg_ty, res_ty) <- splitFunTy_maybe ty-      , let (subst', b) = freshEtaId n subst arg_ty-      = go (n-1) res_ty subst' (b : rev_bs) (e `App` Var b)-      | otherwise-      = pprPanic "etaBodyForJoinPoint" $ int need_args $$-                                         ppr body $$ ppr (exprType body)--    init_subst e = mkEmptyTCvSubst (mkInScopeSet (exprFreeVars e))-----------------freshEtaId :: Int -> TCvSubst -> Type -> (TCvSubst, Id)--- Make a fresh Id, with specified type (after applying substitution)--- It should be "fresh" in the sense that it's not in the in-scope set--- of the TvSubstEnv; and it should itself then be added to the in-scope--- set of the TvSubstEnv------ The Int is just a reasonable starting point for generating a unique;--- it does not necessarily have to be unique itself.-freshEtaId n subst ty-      = (subst', eta_id')-      where-        ty'     = Type.substTyUnchecked subst ty-        eta_id' = uniqAway (getTCvInScope subst) $-                  mkSysLocalOrCoVar (fsLit "eta") (mkBuiltinUnique n) ty'-                  -- "OrCoVar" since this can be used to eta-expand-                  -- coercion abstractions-        subst'  = extendTCvInScope subst eta_id'

− compiler/coreSyn/CoreFVs.hs

@@ -1,778 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--Taken quite directly from the Peyton Jones/Lester paper.--}--{-# LANGUAGE CPP #-}---- | A module concerned with finding the free variables of an expression.-module CoreFVs (-        -- * Free variables of expressions and binding groups-        exprFreeVars,-        exprFreeVarsDSet,-        exprFreeVarsList,-        exprFreeIds,-        exprFreeIdsDSet,-        exprFreeIdsList,-        exprsFreeIdsDSet,-        exprsFreeIdsList,-        exprsFreeVars,-        exprsFreeVarsList,-        bindFreeVars,--        -- * Selective free variables of expressions-        InterestingVarFun,-        exprSomeFreeVars, exprsSomeFreeVars,-        exprSomeFreeVarsList, exprsSomeFreeVarsList,--        -- * Free variables of Rules, Vars and Ids-        varTypeTyCoVars,-        varTypeTyCoFVs,-        idUnfoldingVars, idFreeVars, dIdFreeVars,-        bndrRuleAndUnfoldingVarsDSet,-        idFVs,-        idRuleVars, idRuleRhsVars, stableUnfoldingVars,-        ruleRhsFreeVars, ruleFreeVars, rulesFreeVars,-        rulesFreeVarsDSet,-        ruleLhsFreeIds, ruleLhsFreeIdsList,--        expr_fvs,--        -- * Orphan names-        orphNamesOfType, orphNamesOfCo, orphNamesOfAxiom,-        orphNamesOfTypes, orphNamesOfCoCon,-        exprsOrphNames, orphNamesOfFamInst,--        -- * Core syntax tree annotation with free variables-        FVAnn,                  -- annotation, abstract-        CoreExprWithFVs,        -- = AnnExpr Id FVAnn-        CoreExprWithFVs',       -- = AnnExpr' Id FVAnn-        CoreBindWithFVs,        -- = AnnBind Id FVAnn-        CoreAltWithFVs,         -- = AnnAlt Id FVAnn-        freeVars,               -- CoreExpr -> CoreExprWithFVs-        freeVarsBind,           -- CoreBind -> DVarSet -> (DVarSet, CoreBindWithFVs)-        freeVarsOf,             -- CoreExprWithFVs -> DIdSet-        freeVarsOfAnn-    ) where--#include "HsVersions.h"--import GhcPrelude--import CoreSyn-import Id-import IdInfo-import NameSet-import UniqSet-import Unique (Uniquable (..))-import Name-import VarSet-import Var-import Type-import TyCoRep-import TyCoFVs-import TyCon-import CoAxiom-import FamInstEnv-import TysPrim( funTyConName )-import Maybes( orElse )-import Util-import BasicTypes( Activation )-import Outputable-import FV--{--************************************************************************-*                                                                      *-\section{Finding the free variables of an expression}-*                                                                      *-************************************************************************--This function simply finds the free variables of an expression.-So far as type variables are concerned, it only finds tyvars that are--        * free in type arguments,-        * free in the type of a binder,--but not those that are free in the type of variable occurrence.--}---- | Find all locally-defined free Ids or type variables in an expression--- returning a non-deterministic set.-exprFreeVars :: CoreExpr -> VarSet-exprFreeVars = fvVarSet . exprFVs---- | Find all locally-defined free Ids or type variables in an expression--- returning a composable FV computation. See Note [FV naming conventions] in FV--- for why export it.-exprFVs :: CoreExpr -> FV-exprFVs = filterFV isLocalVar . expr_fvs---- | Find all locally-defined free Ids or type variables in an expression--- returning a deterministic set.-exprFreeVarsDSet :: CoreExpr -> DVarSet-exprFreeVarsDSet = fvDVarSet . exprFVs---- | Find all locally-defined free Ids or type variables in an expression--- returning a deterministically ordered list.-exprFreeVarsList :: CoreExpr -> [Var]-exprFreeVarsList = fvVarList . exprFVs---- | Find all locally-defined free Ids in an expression-exprFreeIds :: CoreExpr -> IdSet        -- Find all locally-defined free Ids-exprFreeIds = exprSomeFreeVars isLocalId---- | Find all locally-defined free Ids in an expression--- returning a deterministic set.-exprFreeIdsDSet :: CoreExpr -> DIdSet -- Find all locally-defined free Ids-exprFreeIdsDSet = exprSomeFreeVarsDSet isLocalId---- | Find all locally-defined free Ids in an expression--- returning a deterministically ordered list.-exprFreeIdsList :: CoreExpr -> [Id] -- Find all locally-defined free Ids-exprFreeIdsList = exprSomeFreeVarsList isLocalId---- | Find all locally-defined free Ids in several expressions--- returning a deterministic set.-exprsFreeIdsDSet :: [CoreExpr] -> DIdSet -- Find all locally-defined free Ids-exprsFreeIdsDSet = exprsSomeFreeVarsDSet isLocalId---- | Find all locally-defined free Ids in several expressions--- returning a deterministically ordered list.-exprsFreeIdsList :: [CoreExpr] -> [Id]   -- Find all locally-defined free Ids-exprsFreeIdsList = exprsSomeFreeVarsList isLocalId---- | Find all locally-defined free Ids or type variables in several expressions--- returning a non-deterministic set.-exprsFreeVars :: [CoreExpr] -> VarSet-exprsFreeVars = fvVarSet . exprsFVs---- | Find all locally-defined free Ids or type variables in several expressions--- returning a composable FV computation. See Note [FV naming conventions] in FV--- for why export it.-exprsFVs :: [CoreExpr] -> FV-exprsFVs exprs = mapUnionFV exprFVs exprs---- | Find all locally-defined free Ids or type variables in several expressions--- returning a deterministically ordered list.-exprsFreeVarsList :: [CoreExpr] -> [Var]-exprsFreeVarsList = fvVarList . exprsFVs---- | Find all locally defined free Ids in a binding group-bindFreeVars :: CoreBind -> VarSet-bindFreeVars (NonRec b r) = fvVarSet $ filterFV isLocalVar $ rhs_fvs (b,r)-bindFreeVars (Rec prs)    = fvVarSet $ filterFV isLocalVar $-                                addBndrs (map fst prs)-                                     (mapUnionFV rhs_fvs prs)---- | Finds free variables in an expression selected by a predicate-exprSomeFreeVars :: InterestingVarFun   -- ^ Says which 'Var's are interesting-                 -> CoreExpr-                 -> VarSet-exprSomeFreeVars fv_cand e = fvVarSet $ filterFV fv_cand $ expr_fvs e---- | Finds free variables in an expression selected by a predicate--- returning a deterministically ordered list.-exprSomeFreeVarsList :: InterestingVarFun -- ^ Says which 'Var's are interesting-                     -> CoreExpr-                     -> [Var]-exprSomeFreeVarsList fv_cand e = fvVarList $ filterFV fv_cand $ expr_fvs e---- | Finds free variables in an expression selected by a predicate--- returning a deterministic set.-exprSomeFreeVarsDSet :: InterestingVarFun -- ^ Says which 'Var's are interesting-                     -> CoreExpr-                     -> DVarSet-exprSomeFreeVarsDSet fv_cand e = fvDVarSet $ filterFV fv_cand $ expr_fvs e---- | Finds free variables in several expressions selected by a predicate-exprsSomeFreeVars :: InterestingVarFun  -- Says which 'Var's are interesting-                  -> [CoreExpr]-                  -> VarSet-exprsSomeFreeVars fv_cand es =-  fvVarSet $ filterFV fv_cand $ mapUnionFV expr_fvs es---- | Finds free variables in several expressions selected by a predicate--- returning a deterministically ordered list.-exprsSomeFreeVarsList :: InterestingVarFun  -- Says which 'Var's are interesting-                      -> [CoreExpr]-                      -> [Var]-exprsSomeFreeVarsList fv_cand es =-  fvVarList $ filterFV fv_cand $ mapUnionFV expr_fvs es---- | Finds free variables in several expressions selected by a predicate--- returning a deterministic set.-exprsSomeFreeVarsDSet :: InterestingVarFun -- ^ Says which 'Var's are interesting-                      -> [CoreExpr]-                      -> DVarSet-exprsSomeFreeVarsDSet fv_cand e =-  fvDVarSet $ filterFV fv_cand $ mapUnionFV expr_fvs e----      Comment about obsolete code--- We used to gather the free variables the RULES at a variable occurrence--- with the following cryptic comment:---     "At a variable occurrence, add in any free variables of its rule rhss---     Curiously, we gather the Id's free *type* variables from its binding---     site, but its free *rule-rhs* variables from its usage sites.  This---     is a little weird.  The reason is that the former is more efficient,---     but the latter is more fine grained, and a makes a difference when---     a variable mentions itself one of its own rule RHSs"--- Not only is this "weird", but it's also pretty bad because it can make--- a function seem more recursive than it is.  Suppose---      f  = ...g...---      g  = ...---         RULE g x = ...f...--- Then f is not mentioned in its own RHS, and needn't be a loop breaker--- (though g may be).  But if we collect the rule fvs from g's occurrence,--- it looks as if f mentions itself.  (This bites in the eftInt/eftIntFB--- code in GHC.Enum.)------ Anyway, it seems plain wrong.  The RULE is like an extra RHS for the--- function, so its free variables belong at the definition site.------ Deleted code looked like---     foldVarSet add_rule_var var_itself_set (idRuleVars var)---     add_rule_var var set | keep_it fv_cand in_scope var = extendVarSet set var---                          | otherwise                    = set---      SLPJ Feb06--addBndr :: CoreBndr -> FV -> FV-addBndr bndr fv fv_cand in_scope acc-  = (varTypeTyCoFVs bndr `unionFV`-        -- Include type variables in the binder's type-        --      (not just Ids; coercion variables too!)-     FV.delFV bndr fv) fv_cand in_scope acc--addBndrs :: [CoreBndr] -> FV -> FV-addBndrs bndrs fv = foldr addBndr fv bndrs--expr_fvs :: CoreExpr -> FV-expr_fvs (Type ty) fv_cand in_scope acc =-  tyCoFVsOfType ty fv_cand in_scope acc-expr_fvs (Coercion co) fv_cand in_scope acc =-  tyCoFVsOfCo co fv_cand in_scope acc-expr_fvs (Var var) fv_cand in_scope acc = FV.unitFV var fv_cand in_scope acc-expr_fvs (Lit _) fv_cand in_scope acc = emptyFV fv_cand in_scope acc-expr_fvs (Tick t expr) fv_cand in_scope acc =-  (tickish_fvs t `unionFV` expr_fvs expr) fv_cand in_scope acc-expr_fvs (App fun arg) fv_cand in_scope acc =-  (expr_fvs fun `unionFV` expr_fvs arg) fv_cand in_scope acc-expr_fvs (Lam bndr body) fv_cand in_scope acc =-  addBndr bndr (expr_fvs body) fv_cand in_scope acc-expr_fvs (Cast expr co) fv_cand in_scope acc =-  (expr_fvs expr `unionFV` tyCoFVsOfCo co) fv_cand in_scope acc--expr_fvs (Case scrut bndr ty alts) fv_cand in_scope acc-  = (expr_fvs scrut `unionFV` tyCoFVsOfType ty `unionFV` addBndr bndr-      (mapUnionFV alt_fvs alts)) fv_cand in_scope acc-  where-    alt_fvs (_, bndrs, rhs) = addBndrs bndrs (expr_fvs rhs)--expr_fvs (Let (NonRec bndr rhs) body) fv_cand in_scope acc-  = (rhs_fvs (bndr, rhs) `unionFV` addBndr bndr (expr_fvs body))-      fv_cand in_scope acc--expr_fvs (Let (Rec pairs) body) fv_cand in_scope acc-  = addBndrs (map fst pairs)-             (mapUnionFV rhs_fvs pairs `unionFV` expr_fvs body)-               fv_cand in_scope acc------------rhs_fvs :: (Id, CoreExpr) -> FV-rhs_fvs (bndr, rhs) = expr_fvs rhs `unionFV`-                      bndrRuleAndUnfoldingFVs bndr-        -- Treat any RULES as extra RHSs of the binding------------exprs_fvs :: [CoreExpr] -> FV-exprs_fvs exprs = mapUnionFV expr_fvs exprs--tickish_fvs :: Tickish Id -> FV-tickish_fvs (Breakpoint _ ids) = FV.mkFVs ids-tickish_fvs _ = emptyFV--{--************************************************************************-*                                                                      *-\section{Free names}-*                                                                      *-************************************************************************--}---- | Finds the free /external/ names of an expression, notably--- including the names of type constructors (which of course do not show--- up in 'exprFreeVars').-exprOrphNames :: CoreExpr -> NameSet--- There's no need to delete local binders, because they will all--- be /internal/ names.-exprOrphNames e-  = go e-  where-    go (Var v)-      | isExternalName n    = unitNameSet n-      | otherwise           = emptyNameSet-      where n = idName v-    go (Lit _)              = emptyNameSet-    go (Type ty)            = orphNamesOfType ty        -- Don't need free tyvars-    go (Coercion co)        = orphNamesOfCo co-    go (App e1 e2)          = go e1 `unionNameSet` go e2-    go (Lam v e)            = go e `delFromNameSet` idName v-    go (Tick _ e)           = go e-    go (Cast e co)          = go e `unionNameSet` orphNamesOfCo co-    go (Let (NonRec _ r) e) = go e `unionNameSet` go r-    go (Let (Rec prs) e)    = exprsOrphNames (map snd prs) `unionNameSet` go e-    go (Case e _ ty as)     = go e `unionNameSet` orphNamesOfType ty-                              `unionNameSet` unionNameSets (map go_alt as)--    go_alt (_,_,r) = go r---- | Finds the free /external/ names of several expressions: see 'exprOrphNames' for details-exprsOrphNames :: [CoreExpr] -> NameSet-exprsOrphNames es = foldr (unionNameSet . exprOrphNames) emptyNameSet es---{- **********************************************************************-%*                                                                      *-                    orphNamesXXX--%*                                                                      *-%********************************************************************* -}--orphNamesOfTyCon :: TyCon -> NameSet-orphNamesOfTyCon tycon = unitNameSet (getName tycon) `unionNameSet` case tyConClass_maybe tycon of-    Nothing  -> emptyNameSet-    Just cls -> unitNameSet (getName cls)--orphNamesOfType :: Type -> NameSet-orphNamesOfType ty | Just ty' <- coreView ty = orphNamesOfType ty'-                -- Look through type synonyms (#4912)-orphNamesOfType (TyVarTy _)          = emptyNameSet-orphNamesOfType (LitTy {})           = emptyNameSet-orphNamesOfType (TyConApp tycon tys) = orphNamesOfTyCon tycon-                                       `unionNameSet` orphNamesOfTypes tys-orphNamesOfType (ForAllTy bndr res)  = orphNamesOfType (binderType bndr)-                                       `unionNameSet` orphNamesOfType res-orphNamesOfType (FunTy _ arg res)    = unitNameSet funTyConName    -- NB!  See #8535-                                       `unionNameSet` orphNamesOfType arg-                                       `unionNameSet` orphNamesOfType res-orphNamesOfType (AppTy fun arg)      = orphNamesOfType fun `unionNameSet` orphNamesOfType arg-orphNamesOfType (CastTy ty co)       = orphNamesOfType ty `unionNameSet` orphNamesOfCo co-orphNamesOfType (CoercionTy co)      = orphNamesOfCo co--orphNamesOfThings :: (a -> NameSet) -> [a] -> NameSet-orphNamesOfThings f = foldr (unionNameSet . f) emptyNameSet--orphNamesOfTypes :: [Type] -> NameSet-orphNamesOfTypes = orphNamesOfThings orphNamesOfType--orphNamesOfMCo :: MCoercion -> NameSet-orphNamesOfMCo MRefl    = emptyNameSet-orphNamesOfMCo (MCo co) = orphNamesOfCo co--orphNamesOfCo :: Coercion -> NameSet-orphNamesOfCo (Refl ty)             = orphNamesOfType ty-orphNamesOfCo (GRefl _ ty mco)      = orphNamesOfType ty `unionNameSet` orphNamesOfMCo mco-orphNamesOfCo (TyConAppCo _ tc cos) = unitNameSet (getName tc) `unionNameSet` orphNamesOfCos cos-orphNamesOfCo (AppCo co1 co2)       = orphNamesOfCo co1 `unionNameSet` orphNamesOfCo co2-orphNamesOfCo (ForAllCo _ kind_co co)-  = orphNamesOfCo kind_co `unionNameSet` orphNamesOfCo co-orphNamesOfCo (FunCo _ co1 co2)     = orphNamesOfCo co1 `unionNameSet` orphNamesOfCo co2-orphNamesOfCo (CoVarCo _)           = emptyNameSet-orphNamesOfCo (AxiomInstCo con _ cos) = orphNamesOfCoCon con `unionNameSet` orphNamesOfCos cos-orphNamesOfCo (UnivCo p _ t1 t2)    = orphNamesOfProv p `unionNameSet` orphNamesOfType t1 `unionNameSet` orphNamesOfType t2-orphNamesOfCo (SymCo co)            = orphNamesOfCo co-orphNamesOfCo (TransCo co1 co2)     = orphNamesOfCo co1 `unionNameSet` orphNamesOfCo co2-orphNamesOfCo (NthCo _ _ co)        = orphNamesOfCo co-orphNamesOfCo (LRCo  _ co)          = orphNamesOfCo co-orphNamesOfCo (InstCo co arg)       = orphNamesOfCo co `unionNameSet` orphNamesOfCo arg-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--orphNamesOfCos :: [Coercion] -> NameSet-orphNamesOfCos = orphNamesOfThings orphNamesOfCo--orphNamesOfCoCon :: CoAxiom br -> NameSet-orphNamesOfCoCon (CoAxiom { co_ax_tc = tc, co_ax_branches = branches })-  = orphNamesOfTyCon tc `unionNameSet` orphNamesOfCoAxBranches branches--orphNamesOfAxiom :: CoAxiom br -> NameSet-orphNamesOfAxiom axiom-  = orphNamesOfTypes (concatMap coAxBranchLHS $ fromBranches $ coAxiomBranches axiom)-    `extendNameSet` getName (coAxiomTyCon axiom)--orphNamesOfCoAxBranches :: Branches br -> NameSet-orphNamesOfCoAxBranches-  = foldr (unionNameSet . orphNamesOfCoAxBranch) emptyNameSet . fromBranches--orphNamesOfCoAxBranch :: CoAxBranch -> NameSet-orphNamesOfCoAxBranch (CoAxBranch { cab_lhs = lhs, cab_rhs = rhs })-  = orphNamesOfTypes lhs `unionNameSet` orphNamesOfType rhs---- | orphNamesOfAxiom collects the names of the concrete types and--- type constructors that make up the LHS of a type family instance,--- including the family name itself.------ For instance, given `type family Foo a b`:--- `type instance Foo (F (G (H a))) b = ...` would yield [Foo,F,G,H]------ Used in the implementation of ":info" in GHCi.-orphNamesOfFamInst :: FamInst -> NameSet-orphNamesOfFamInst fam_inst = orphNamesOfAxiom (famInstAxiom fam_inst)--{--************************************************************************-*                                                                      *-\section[freevars-everywhere]{Attaching free variables to every sub-expression}-*                                                                      *-************************************************************************--}---- | Those variables free in the right hand side of a rule returned as a--- non-deterministic set-ruleRhsFreeVars :: CoreRule -> VarSet-ruleRhsFreeVars (BuiltinRule {}) = noFVs-ruleRhsFreeVars (Rule { ru_fn = _, ru_bndrs = bndrs, ru_rhs = rhs })-  = fvVarSet $ filterFV isLocalVar $ addBndrs bndrs (expr_fvs rhs)-      -- See Note [Rule free var hack]---- | Those variables free in the both the left right hand sides of a rule--- returned as a non-deterministic set-ruleFreeVars :: CoreRule -> VarSet-ruleFreeVars = fvVarSet . ruleFVs---- | Those variables free in the both the left right hand sides of a rule--- returned as FV computation-ruleFVs :: CoreRule -> FV-ruleFVs (BuiltinRule {}) = emptyFV-ruleFVs (Rule { ru_fn = _do_not_include-                  -- See Note [Rule free var hack]-              , ru_bndrs = bndrs-              , ru_rhs = rhs, ru_args = args })-  = filterFV isLocalVar $ addBndrs bndrs (exprs_fvs (rhs:args))---- | Those variables free in the both the left right hand sides of rules--- returned as FV computation-rulesFVs :: [CoreRule] -> FV-rulesFVs = mapUnionFV ruleFVs---- | Those variables free in the both the left right hand sides of rules--- returned as a deterministic set-rulesFreeVarsDSet :: [CoreRule] -> DVarSet-rulesFreeVarsDSet rules = fvDVarSet $ rulesFVs rules--idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet--- Just the variables free on the *rhs* of a rule-idRuleRhsVars is_active id-  = mapUnionVarSet get_fvs (idCoreRules id)-  where-    get_fvs (Rule { ru_fn = fn, ru_bndrs = bndrs-                  , ru_rhs = rhs, ru_act = act })-      | is_active act-            -- See Note [Finding rule RHS free vars] in OccAnal.hs-      = delOneFromUniqSet_Directly fvs (getUnique fn)-            -- Note [Rule free var hack]-      where-        fvs = fvVarSet $ filterFV isLocalVar $ addBndrs bndrs (expr_fvs rhs)-    get_fvs _ = noFVs---- | Those variables free in the right hand side of several rules-rulesFreeVars :: [CoreRule] -> VarSet-rulesFreeVars rules = mapUnionVarSet ruleFreeVars rules--ruleLhsFreeIds :: CoreRule -> VarSet--- ^ This finds all locally-defined free Ids on the left hand side of a rule--- and returns them as a non-deterministic set-ruleLhsFreeIds = fvVarSet . ruleLhsFVIds--ruleLhsFreeIdsList :: CoreRule -> [Var]--- ^ This finds all locally-defined free Ids on the left hand side of a rule--- and returns them as a deterministically ordered list-ruleLhsFreeIdsList = fvVarList . ruleLhsFVIds--ruleLhsFVIds :: CoreRule -> FV--- ^ This finds all locally-defined free Ids on the left hand side of a rule--- and returns an FV computation-ruleLhsFVIds (BuiltinRule {}) = emptyFV-ruleLhsFVIds (Rule { ru_bndrs = bndrs, ru_args = args })-  = filterFV isLocalId $ addBndrs bndrs (exprs_fvs args)--{--Note [Rule free var hack]  (Not a hack any more)-~~~~~~~~~~~~~~~~~~~~~~~~~-We used not to include the Id in its own rhs free-var set.-Otherwise the occurrence analyser makes bindings recursive:-        f x y = x+y-        RULE:  f (f x y) z  ==>  f x (f y z)-However, the occurrence analyser distinguishes "non-rule loop breakers"-from "rule-only loop breakers" (see BasicTypes.OccInfo).  So it will-put this 'f' in a Rec block, but will mark the binding as a non-rule loop-breaker, which is perfectly inlinable.--}--{--************************************************************************-*                                                                      *-\section[freevars-everywhere]{Attaching free variables to every sub-expression}-*                                                                      *-************************************************************************--The free variable pass annotates every node in the expression with its-NON-GLOBAL free variables and type variables.--}--type FVAnn = DVarSet  -- See Note [The FVAnn invariant]--{- Note [The FVAnn invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Invariant: a FVAnn, say S, is closed:-  That is: if v is in S,-           then freevars( v's type/kind ) is also in S--}---- | Every node in a binding group annotated with its--- (non-global) free variables, both Ids and TyVars, and type.-type CoreBindWithFVs = AnnBind Id FVAnn---- | Every node in an expression annotated with its--- (non-global) free variables, both Ids and TyVars, and type.--- NB: see Note [The FVAnn invariant]-type CoreExprWithFVs  = AnnExpr  Id FVAnn-type CoreExprWithFVs' = AnnExpr' Id FVAnn---- | Every node in an expression annotated with its--- (non-global) free variables, both Ids and TyVars, and type.-type CoreAltWithFVs = AnnAlt Id FVAnn--freeVarsOf :: CoreExprWithFVs -> DIdSet--- ^ Inverse function to 'freeVars'-freeVarsOf (fvs, _) = fvs---- | Extract the vars reported in a FVAnn-freeVarsOfAnn :: FVAnn -> DIdSet-freeVarsOfAnn fvs = fvs--noFVs :: VarSet-noFVs = emptyVarSet--aFreeVar :: Var -> DVarSet-aFreeVar = unitDVarSet--unionFVs :: DVarSet -> DVarSet -> DVarSet-unionFVs = unionDVarSet--unionFVss :: [DVarSet] -> DVarSet-unionFVss = unionDVarSets--delBindersFV :: [Var] -> DVarSet -> DVarSet-delBindersFV bs fvs = foldr delBinderFV fvs bs--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,---   * 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.------ Also in---      let x::a = b in ...--- we should really note that "a" is free in this expression.--- It'll be pinned inside the /\a by the binding for b, but--- it seems cleaner to make sure that a is in the free-var set--- when it is mentioned.------ This also shows up in recursive bindings.  Consider:---      /\a -> letrec x::a = x in E--- Now, there are no explicit free type variables in the RHS of x,--- but nevertheless "a" is free in its definition.  So we add in--- the free tyvars of the types of the binders, and include these in the--- free vars of the group, attached to the top level of each RHS.------ This actually happened in the defn of errorIO in IOBase.hs:---      errorIO (ST io) = case (errorIO# io) of---                          _ -> bottom---                        where---                          bottom = bottom -- Never evaluated--delBinderFV b s = (s `delDVarSet` b) `unionFVs` dVarTypeTyCoVars b-        -- Include coercion variables too!--varTypeTyCoVars :: Var -> TyCoVarSet--- Find the type/kind variables free in the type of the id/tyvar-varTypeTyCoVars var = fvVarSet $ varTypeTyCoFVs var--dVarTypeTyCoVars :: Var -> DTyCoVarSet--- Find the type/kind/coercion variables free in the type of the id/tyvar-dVarTypeTyCoVars var = fvDVarSet $ varTypeTyCoFVs var--varTypeTyCoFVs :: Var -> FV-varTypeTyCoFVs var = tyCoFVsOfType (varType var)--idFreeVars :: Id -> VarSet-idFreeVars id = ASSERT( isId id) fvVarSet $ idFVs id--dIdFreeVars :: Id -> DVarSet-dIdFreeVars id = fvDVarSet $ idFVs id--idFVs :: Id -> FV--- Type variables, rule variables, and inline variables-idFVs id = ASSERT( isId id)-           varTypeTyCoFVs id `unionFV`-           bndrRuleAndUnfoldingFVs id--bndrRuleAndUnfoldingVarsDSet :: Id -> DVarSet-bndrRuleAndUnfoldingVarsDSet id = fvDVarSet $ bndrRuleAndUnfoldingFVs id--bndrRuleAndUnfoldingFVs :: Id -> FV-bndrRuleAndUnfoldingFVs id-  | isId id   = idRuleFVs id `unionFV` idUnfoldingFVs id-  | otherwise = emptyFV--idRuleVars ::Id -> VarSet  -- Does *not* include CoreUnfolding vars-idRuleVars id = fvVarSet $ idRuleFVs id--idRuleFVs :: Id -> FV-idRuleFVs id = ASSERT( isId id)-  FV.mkFVs (dVarSetElems $ ruleInfoFreeVars (idSpecialisation id))--idUnfoldingVars :: Id -> VarSet--- Produce free vars for an unfolding, but NOT for an ordinary--- (non-inline) unfolding, since it is a dup of the rhs--- and we'll get exponential behaviour if we look at both unf and rhs!--- But do look at the *real* unfolding, even for loop breakers, else--- we might get out-of-scope variables-idUnfoldingVars id = fvVarSet $ idUnfoldingFVs id--idUnfoldingFVs :: Id -> FV-idUnfoldingFVs id = stableUnfoldingFVs (realIdUnfolding id) `orElse` emptyFV--stableUnfoldingVars :: Unfolding -> Maybe VarSet-stableUnfoldingVars unf = fvVarSet `fmap` stableUnfoldingFVs unf--stableUnfoldingFVs :: Unfolding -> Maybe FV-stableUnfoldingFVs unf-  = case unf of-      CoreUnfolding { uf_tmpl = rhs, uf_src = src }-         | isStableSource src-         -> Just (filterFV isLocalVar $ expr_fvs rhs)-      DFunUnfolding { df_bndrs = bndrs, df_args = args }-         -> Just (filterFV isLocalVar $ FV.delFVs (mkVarSet bndrs) $ exprs_fvs args)-            -- DFuns are top level, so no fvs from types of bndrs-      _other -> Nothing---{--************************************************************************-*                                                                      *-\subsection{Free variables (and types)}-*                                                                      *-************************************************************************--}--freeVarsBind :: CoreBind-             -> DVarSet                     -- Free vars of scope of binding-             -> (CoreBindWithFVs, DVarSet)  -- Return free vars of binding + scope-freeVarsBind (NonRec binder rhs) body_fvs-  = ( AnnNonRec binder rhs2-    , freeVarsOf rhs2 `unionFVs` body_fvs2-                      `unionFVs` bndrRuleAndUnfoldingVarsDSet binder )-    where-      rhs2      = freeVars rhs-      body_fvs2 = binder `delBinderFV` body_fvs--freeVarsBind (Rec binds) body_fvs-  = ( AnnRec (binders `zip` rhss2)-    , delBindersFV binders all_fvs )-  where-    (binders, rhss) = unzip binds-    rhss2        = map freeVars rhss-    rhs_body_fvs = foldr (unionFVs . freeVarsOf) body_fvs rhss2-    binders_fvs  = fvDVarSet $ mapUnionFV bndrRuleAndUnfoldingFVs binders-                   -- See Note [The FVAnn invariant]-    all_fvs      = rhs_body_fvs `unionFVs` binders_fvs-            -- The "delBinderFV" happens after adding the idSpecVars,-            -- since the latter may add some of the binders as fvs--freeVars :: CoreExpr -> CoreExprWithFVs--- ^ Annotate a 'CoreExpr' with its (non-global) free type---   and value variables at every tree node.-freeVars = go-  where-    go :: CoreExpr -> CoreExprWithFVs-    go (Var v)-      | isLocalVar v = (aFreeVar v `unionFVs` ty_fvs, AnnVar v)-      | otherwise    = (emptyDVarSet,                 AnnVar v)-      where-        ty_fvs = dVarTypeTyCoVars v-                 -- See Note [The FVAnn invariant]--    go (Lit lit) = (emptyDVarSet, AnnLit lit)-    go (Lam b body)-      = ( b_fvs `unionFVs` (b `delBinderFV` body_fvs)-        , AnnLam b body' )-      where-        body'@(body_fvs, _) = go body-        b_ty  = idType b-        b_fvs = tyCoVarsOfTypeDSet b_ty-                -- See Note [The FVAnn invariant]--    go (App fun arg)-      = ( freeVarsOf fun' `unionFVs` freeVarsOf arg'-        , AnnApp fun' arg' )-      where-        fun'   = go fun-        arg'   = go arg--    go (Case scrut bndr ty alts)-      = ( (bndr `delBinderFV` alts_fvs)-           `unionFVs` freeVarsOf scrut2-           `unionFVs` tyCoVarsOfTypeDSet ty-          -- Don't need to look at (idType bndr)-          -- because that's redundant with scrut-        , AnnCase scrut2 bndr ty alts2 )-      where-        scrut2 = go scrut--        (alts_fvs_s, alts2) = mapAndUnzip fv_alt alts-        alts_fvs            = unionFVss alts_fvs_s--        fv_alt (con,args,rhs) = (delBindersFV args (freeVarsOf rhs2),-                                 (con, args, rhs2))-                              where-                                 rhs2 = go rhs--    go (Let bind body)-      = (bind_fvs, AnnLet bind2 body2)-      where-        (bind2, bind_fvs) = freeVarsBind bind (freeVarsOf body2)-        body2             = go body--    go (Cast expr co)-      = ( freeVarsOf expr2 `unionFVs` cfvs-        , AnnCast expr2 (cfvs, co) )-      where-        expr2 = go expr-        cfvs  = tyCoVarsOfCoDSet co--    go (Tick tickish expr)-      = ( tickishFVs tickish `unionFVs` freeVarsOf expr2-        , AnnTick tickish expr2 )-      where-        expr2 = go expr-        tickishFVs (Breakpoint _ ids) = mkDVarSet ids-        tickishFVs _                  = emptyDVarSet--    go (Type ty)     = (tyCoVarsOfTypeDSet ty, AnnType ty)-    go (Coercion co) = (tyCoVarsOfCoDSet co, AnnCoercion co)

− compiler/coreSyn/CoreMap.hs

@@ -1,803 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--}--{-# LANGUAGE CPP #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE TypeSynonymInstances #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-}--module CoreMap(-   -- * Maps over Core expressions-   CoreMap, emptyCoreMap, extendCoreMap, lookupCoreMap, foldCoreMap,-   -- * Maps over 'Type's-   TypeMap, emptyTypeMap, extendTypeMap, lookupTypeMap, foldTypeMap,-   LooseTypeMap,-   -- ** With explicit scoping-   CmEnv, lookupCME, extendTypeMapWithScope, lookupTypeMapWithScope,-   mkDeBruijnContext,-   -- * Maps over 'Maybe' values-   MaybeMap,-   -- * Maps over 'List' values-   ListMap,-   -- * Maps over 'Literal's-   LiteralMap,-   -- * Map for compressing leaves. See Note [Compressed TrieMap]-   GenMap,-   -- * 'TrieMap' class-   TrieMap(..), insertTM, deleteTM,-   lkDFreeVar, xtDFreeVar,-   lkDNamed, xtDNamed,-   (>.>), (|>), (|>>),- ) where--#include "HsVersions.h"--import GhcPrelude--import TrieMap-import CoreSyn-import Coercion-import Name-import Type-import TyCoRep-import Var-import FastString(FastString)-import Util--import qualified Data.Map    as Map-import qualified Data.IntMap as IntMap-import VarEnv-import NameEnv-import Outputable-import Control.Monad( (>=>) )--{--This module implements TrieMaps over Core related data structures-like CoreExpr or Type. It is built on the Tries from the TrieMap-module.--The code is very regular and boilerplate-like, but there is-some neat handling of *binders*.  In effect they are deBruijn-numbered on the fly.----}--------------------------- Recall that---   Control.Monad.(>=>) :: (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c---- NB: Be careful about RULES and type families (#5821).  So we should make sure--- to specify @Key TypeMapX@ (and not @DeBruijn Type@, the reduced form)---- The CoreMap makes heavy use of GenMap. However the CoreMap Types are not--- known when defining GenMap so we can only specialize them here.--{-# SPECIALIZE lkG :: Key TypeMapX     -> TypeMapG a     -> Maybe a #-}-{-# SPECIALIZE lkG :: Key CoercionMapX -> CoercionMapG a -> Maybe a #-}-{-# SPECIALIZE lkG :: Key CoreMapX     -> CoreMapG a     -> Maybe a #-}---{-# SPECIALIZE xtG :: Key TypeMapX     -> XT a -> TypeMapG a -> TypeMapG a #-}-{-# SPECIALIZE xtG :: Key CoercionMapX -> XT a -> CoercionMapG a -> CoercionMapG a #-}-{-# SPECIALIZE xtG :: Key CoreMapX     -> XT a -> CoreMapG a -> CoreMapG a #-}--{-# SPECIALIZE mapG :: (a -> b) -> TypeMapG a     -> TypeMapG b #-}-{-# SPECIALIZE mapG :: (a -> b) -> CoercionMapG a -> CoercionMapG b #-}-{-# SPECIALIZE mapG :: (a -> b) -> CoreMapG a     -> CoreMapG b #-}--{-# SPECIALIZE fdG :: (a -> b -> b) -> TypeMapG a     -> b -> b #-}-{-# SPECIALIZE fdG :: (a -> b -> b) -> CoercionMapG a -> b -> b #-}-{-# SPECIALIZE fdG :: (a -> b -> b) -> CoreMapG a     -> b -> b #-}---{--************************************************************************-*                                                                      *-                   CoreMap-*                                                                      *-************************************************************************--}--lkDNamed :: NamedThing n => n -> DNameEnv a -> Maybe a-lkDNamed n env = lookupDNameEnv env (getName n)--xtDNamed :: NamedThing n => n -> XT a -> DNameEnv a -> DNameEnv a-xtDNamed tc f m = alterDNameEnv f m (getName tc)---{--Note [Binders]-~~~~~~~~~~~~~~- * In general we check binders as late as possible because types are-   less likely to differ than expression structure.  That's why-      cm_lam :: CoreMapG (TypeMapG a)-   rather than-      cm_lam :: TypeMapG (CoreMapG a)-- * 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--Note [Empty case alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-* For a key (Case e b ty (alt:alts))  we don't need to look the return type-  'ty', because every alternative has that type.--* For a key (Case e b ty []) we MUST look at the return type 'ty', because-  otherwise (Case (error () "urk") _ Int  []) would compare equal to-            (Case (error () "urk") _ Bool [])-  which is utterly wrong (#6097)--We could compare the return type regardless, but the wildly common case-is that it's unnecessary, so we have two fields (cm_case and cm_ecase)-for the two possibilities.  Only cm_ecase looks at the type.--See also Note [Empty case alternatives] in CoreSyn.--}---- | @CoreMap a@ is a map from 'CoreExpr' to @a@.  If you are a client, this--- is the type you want.-newtype CoreMap a = CoreMap (CoreMapG a)--instance TrieMap CoreMap where-    type Key CoreMap = CoreExpr-    emptyTM = CoreMap emptyTM-    lookupTM k (CoreMap m) = lookupTM (deBruijnize k) m-    alterTM k f (CoreMap m) = CoreMap (alterTM (deBruijnize k) f m)-    foldTM k (CoreMap m) = foldTM k m-    mapTM f (CoreMap m) = CoreMap (mapTM f m)---- | @CoreMapG a@ is a map from @DeBruijn CoreExpr@ to @a@.  The extended--- key makes it suitable for recursive traversal, since it can track binders,--- but it is strictly internal to this module.  If you are including a 'CoreMap'--- inside another 'TrieMap', this is the type you want.-type CoreMapG = GenMap CoreMapX---- | @CoreMapX a@ is the base map from @DeBruijn CoreExpr@ to @a@, but without--- the 'GenMap' optimization.-data CoreMapX a-  = CM { cm_var   :: VarMap a-       , cm_lit   :: LiteralMap a-       , cm_co    :: CoercionMapG a-       , cm_type  :: TypeMapG a-       , cm_cast  :: CoreMapG (CoercionMapG a)-       , cm_tick  :: CoreMapG (TickishMap a)-       , cm_app   :: CoreMapG (CoreMapG a)-       , cm_lam   :: CoreMapG (BndrMap a)    -- Note [Binders]-       , cm_letn  :: CoreMapG (CoreMapG (BndrMap a))-       , cm_letr  :: ListMap CoreMapG (CoreMapG (ListMap BndrMap a))-       , cm_case  :: CoreMapG (ListMap AltMap a)-       , cm_ecase :: CoreMapG (TypeMapG a)    -- Note [Empty case alternatives]-     }--instance Eq (DeBruijn CoreExpr) where-  D env1 e1 == D env2 e2 = go e1 e2 where-    go (Var v1) (Var v2) = case (lookupCME env1 v1, lookupCME env2 v2) of-                            (Just b1, Just b2) -> b1 == b2-                            (Nothing, Nothing) -> v1 == v2-                            _ -> False-    go (Lit lit1)    (Lit lit2)      = lit1 == lit2-    go (Type t1)    (Type t2)        = D env1 t1 == D env2 t2-    go (Coercion co1) (Coercion co2) = D env1 co1 == D env2 co2-    go (Cast e1 co1) (Cast e2 co2) = D env1 co1 == D env2 co2 && go e1 e2-    go (App f1 a1)   (App f2 a2)   = go f1 f2 && go a1 a2-    -- This seems a bit dodgy, see 'eqTickish'-    go (Tick n1 e1)  (Tick n2 e2)  = n1 == n2 && go e1 e2--    go (Lam b1 e1)  (Lam b2 e2)-      =  D env1 (varType b1) == D env2 (varType b2)-      && D (extendCME env1 b1) e1 == D (extendCME env2 b2) e2--    go (Let (NonRec v1 r1) e1) (Let (NonRec v2 r2) e2)-      =  go r1 r2-      && D (extendCME env1 v1) e1 == D (extendCME env2 v2) e2--    go (Let (Rec ps1) e1) (Let (Rec ps2) e2)-      = equalLength ps1 ps2-      && D env1' rs1 == D env2' rs2-      && D env1' e1  == D env2' e2-      where-        (bs1,rs1) = unzip ps1-        (bs2,rs2) = unzip ps2-        env1' = extendCMEs env1 bs1-        env2' = extendCMEs env2 bs2--    go (Case e1 b1 t1 a1) (Case e2 b2 t2 a2)-      | null a1   -- See Note [Empty case alternatives]-      = null a2 && go e1 e2 && D env1 t1 == D env2 t2-      | otherwise-      =  go e1 e2 && D (extendCME env1 b1) a1 == D (extendCME env2 b2) a2--    go _ _ = False--emptyE :: CoreMapX a-emptyE = CM { cm_var = emptyTM, cm_lit = emptyTM-            , cm_co = emptyTM, cm_type = emptyTM-            , cm_cast = emptyTM, cm_app = emptyTM-            , cm_lam = emptyTM, cm_letn = emptyTM-            , cm_letr = emptyTM, cm_case = emptyTM-            , cm_ecase = emptyTM, cm_tick = emptyTM }--instance TrieMap CoreMapX where-   type Key CoreMapX = DeBruijn CoreExpr-   emptyTM  = emptyE-   lookupTM = lkE-   alterTM  = xtE-   foldTM   = fdE-   mapTM    = mapE-----------------------------mapE :: (a->b) -> CoreMapX a -> CoreMapX b-mapE f (CM { cm_var = cvar, cm_lit = clit-           , cm_co = cco, cm_type = ctype-           , cm_cast = ccast , cm_app = capp-           , cm_lam = clam, cm_letn = cletn-           , cm_letr = cletr, cm_case = ccase-           , cm_ecase = cecase, cm_tick = ctick })-  = CM { cm_var = mapTM f cvar, cm_lit = mapTM f clit-       , cm_co = mapTM f cco, cm_type = mapTM f ctype-       , cm_cast = mapTM (mapTM f) ccast, cm_app = mapTM (mapTM f) capp-       , cm_lam = mapTM (mapTM f) clam, cm_letn = mapTM (mapTM (mapTM f)) cletn-       , cm_letr = mapTM (mapTM (mapTM f)) cletr, cm_case = mapTM (mapTM f) ccase-       , cm_ecase = mapTM (mapTM f) cecase, cm_tick = mapTM (mapTM f) ctick }-----------------------------lookupCoreMap :: CoreMap a -> CoreExpr -> Maybe a-lookupCoreMap cm e = lookupTM e cm--extendCoreMap :: CoreMap a -> CoreExpr -> a -> CoreMap a-extendCoreMap m e v = alterTM e (\_ -> Just v) m--foldCoreMap :: (a -> b -> b) -> b -> CoreMap a -> b-foldCoreMap k z m = foldTM k m z--emptyCoreMap :: CoreMap a-emptyCoreMap = emptyTM--instance Outputable a => Outputable (CoreMap a) where-  ppr m = text "CoreMap elts" <+> ppr (foldTM (:) m [])----------------------------fdE :: (a -> b -> b) -> CoreMapX a -> b -> b-fdE k m-  = foldTM k (cm_var m)-  . foldTM k (cm_lit m)-  . foldTM k (cm_co m)-  . foldTM k (cm_type m)-  . foldTM (foldTM k) (cm_cast m)-  . foldTM (foldTM k) (cm_tick m)-  . foldTM (foldTM k) (cm_app m)-  . foldTM (foldTM k) (cm_lam m)-  . foldTM (foldTM (foldTM k)) (cm_letn m)-  . foldTM (foldTM (foldTM k)) (cm_letr m)-  . foldTM (foldTM k) (cm_case m)-  . foldTM (foldTM k) (cm_ecase m)---- lkE: lookup in trie for expressions-lkE :: DeBruijn CoreExpr -> CoreMapX a -> Maybe a-lkE (D env expr) cm = go expr cm-  where-    go (Var v)              = cm_var  >.> lkVar env v-    go (Lit l)              = cm_lit  >.> lookupTM l-    go (Type t)             = cm_type >.> lkG (D env t)-    go (Coercion c)         = cm_co   >.> lkG (D env c)-    go (Cast e c)           = cm_cast >.> lkG (D env e) >=> lkG (D env c)-    go (Tick tickish e)     = cm_tick >.> lkG (D env e) >=> lkTickish tickish-    go (App e1 e2)          = cm_app  >.> lkG (D env e2) >=> lkG (D env e1)-    go (Lam v e)            = cm_lam  >.> lkG (D (extendCME env v) e)-                              >=> lkBndr env v-    go (Let (NonRec b r) e) = cm_letn >.> lkG (D env r)-                              >=> lkG (D (extendCME env b) e) >=> lkBndr env b-    go (Let (Rec prs) e)    = let (bndrs,rhss) = unzip prs-                                  env1 = extendCMEs env bndrs-                              in cm_letr-                                 >.> lkList (lkG . D env1) rhss-                                 >=> lkG (D env1 e)-                                 >=> lkList (lkBndr env1) bndrs-    go (Case e b ty as)     -- See Note [Empty case alternatives]-               | null as    = cm_ecase >.> lkG (D env e) >=> lkG (D env ty)-               | otherwise  = cm_case >.> lkG (D env e)-                              >=> lkList (lkA (extendCME env b)) as--xtE :: DeBruijn CoreExpr -> XT a -> CoreMapX a -> CoreMapX a-xtE (D env (Var v))              f m = m { cm_var  = cm_var m-                                                 |> xtVar env v f }-xtE (D env (Type t))             f m = m { cm_type = cm_type m-                                                 |> xtG (D env t) f }-xtE (D env (Coercion c))         f m = m { cm_co   = cm_co m-                                                 |> xtG (D env c) f }-xtE (D _   (Lit l))              f m = m { cm_lit  = cm_lit m  |> alterTM l f }-xtE (D env (Cast e c))           f m = m { cm_cast = cm_cast m |> xtG (D env e)-                                                 |>> xtG (D env c) f }-xtE (D env (Tick t e))           f m = m { cm_tick = cm_tick m |> xtG (D env e)-                                                 |>> xtTickish t f }-xtE (D env (App e1 e2))          f m = m { cm_app = cm_app m |> xtG (D env e2)-                                                 |>> xtG (D env e1) f }-xtE (D env (Lam v e))            f m = m { cm_lam = cm_lam m-                                                 |> xtG (D (extendCME env v) e)-                                                 |>> xtBndr env v f }-xtE (D env (Let (NonRec b r) e)) f m = m { cm_letn = cm_letn m-                                                 |> xtG (D (extendCME env b) e)-                                                 |>> xtG (D env r)-                                                 |>> xtBndr env b f }-xtE (D env (Let (Rec prs) e))    f m = m { cm_letr =-                                              let (bndrs,rhss) = unzip prs-                                                  env1 = extendCMEs env bndrs-                                              in cm_letr m-                                                 |>  xtList (xtG . D env1) rhss-                                                 |>> xtG (D env1 e)-                                                 |>> xtList (xtBndr env1)-                                                            bndrs f }-xtE (D env (Case e b ty as))     f m-                     | null as   = m { cm_ecase = cm_ecase m |> xtG (D env e)-                                                 |>> xtG (D env ty) f }-                     | otherwise = m { cm_case = cm_case m |> xtG (D env e)-                                                 |>> let env1 = extendCME env b-                                                     in xtList (xtA env1) as f }---- TODO: this seems a bit dodgy, see 'eqTickish'-type TickishMap a = Map.Map (Tickish Id) a-lkTickish :: Tickish Id -> TickishMap a -> Maybe a-lkTickish = lookupTM--xtTickish :: Tickish Id -> XT a -> TickishMap a -> TickishMap a-xtTickish = alterTM---------------------------data AltMap a   -- A single alternative-  = AM { am_deflt :: CoreMapG a-       , am_data  :: DNameEnv (CoreMapG a)-       , am_lit   :: LiteralMap (CoreMapG a) }--instance TrieMap AltMap where-   type Key AltMap = CoreAlt-   emptyTM  = AM { am_deflt = emptyTM-                 , am_data = emptyDNameEnv-                 , am_lit  = emptyTM }-   lookupTM = lkA emptyCME-   alterTM  = xtA emptyCME-   foldTM   = fdA-   mapTM    = mapA--instance Eq (DeBruijn CoreAlt) where-  D env1 a1 == D env2 a2 = go a1 a2 where-    go (DEFAULT, _, rhs1) (DEFAULT, _, rhs2)-        = D env1 rhs1 == D env2 rhs2-    go (LitAlt lit1, _, rhs1) (LitAlt lit2, _, rhs2)-        = lit1 == lit2 && D env1 rhs1 == D env2 rhs2-    go (DataAlt dc1, bs1, rhs1) (DataAlt dc2, bs2, rhs2)-        = dc1 == dc2 &&-          D (extendCMEs env1 bs1) rhs1 == D (extendCMEs env2 bs2) rhs2-    go _ _ = False--mapA :: (a->b) -> AltMap a -> AltMap b-mapA f (AM { am_deflt = adeflt, am_data = adata, am_lit = alit })-  = AM { am_deflt = mapTM f adeflt-       , am_data = mapTM (mapTM f) adata-       , am_lit = mapTM (mapTM f) alit }--lkA :: CmEnv -> CoreAlt -> AltMap a -> Maybe a-lkA env (DEFAULT,    _, rhs)  = am_deflt >.> lkG (D env rhs)-lkA env (LitAlt lit, _, rhs)  = am_lit >.> lookupTM lit >=> lkG (D env rhs)-lkA env (DataAlt dc, bs, rhs) = am_data >.> lkDNamed dc-                                        >=> lkG (D (extendCMEs env bs) rhs)--xtA :: CmEnv -> CoreAlt -> XT a -> AltMap a -> AltMap a-xtA env (DEFAULT, _, rhs)    f m =-    m { am_deflt = am_deflt m |> xtG (D env rhs) f }-xtA env (LitAlt l, _, rhs)   f m =-    m { am_lit   = am_lit m   |> alterTM l |>> xtG (D env rhs) f }-xtA env (DataAlt d, bs, rhs) f m =-    m { am_data  = am_data m  |> xtDNamed d-                             |>> xtG (D (extendCMEs env bs) rhs) f }--fdA :: (a -> b -> b) -> AltMap a -> b -> b-fdA k m = foldTM k (am_deflt m)-        . foldTM (foldTM k) (am_data m)-        . foldTM (foldTM k) (am_lit m)--{--************************************************************************-*                                                                      *-                   Coercions-*                                                                      *-************************************************************************--}---- We should really never care about the contents of a coercion. Instead,--- just look up the coercion's type.-newtype CoercionMap a = CoercionMap (CoercionMapG a)--instance TrieMap CoercionMap where-   type Key CoercionMap = Coercion-   emptyTM                     = CoercionMap emptyTM-   lookupTM k  (CoercionMap m) = lookupTM (deBruijnize k) m-   alterTM k f (CoercionMap m) = CoercionMap (alterTM (deBruijnize k) f m)-   foldTM k    (CoercionMap m) = foldTM k m-   mapTM f     (CoercionMap m) = CoercionMap (mapTM f m)--type CoercionMapG = GenMap CoercionMapX-newtype CoercionMapX a = CoercionMapX (TypeMapX a)--instance TrieMap CoercionMapX where-  type Key CoercionMapX = DeBruijn Coercion-  emptyTM = CoercionMapX emptyTM-  lookupTM = lkC-  alterTM  = xtC-  foldTM f (CoercionMapX core_tm) = foldTM f core_tm-  mapTM f (CoercionMapX core_tm)  = CoercionMapX (mapTM f core_tm)--instance Eq (DeBruijn Coercion) where-  D env1 co1 == D env2 co2-    = D env1 (coercionType co1) ==-      D env2 (coercionType co2)--lkC :: DeBruijn Coercion -> CoercionMapX a -> Maybe a-lkC (D env co) (CoercionMapX core_tm) = lkT (D env $ coercionType co)-                                        core_tm--xtC :: DeBruijn Coercion -> XT a -> CoercionMapX a -> CoercionMapX a-xtC (D env co) f (CoercionMapX m)-  = CoercionMapX (xtT (D env $ coercionType co) f m)--{--************************************************************************-*                                                                      *-                   Types-*                                                                      *-************************************************************************--}---- | @TypeMapG a@ is a map from @DeBruijn Type@ to @a@.  The extended--- key makes it suitable for recursive traversal, since it can track binders,--- but it is strictly internal to this module.  If you are including a 'TypeMap'--- inside another 'TrieMap', this is the type you want. Note that this--- lookup does not do a kind-check. Thus, all keys in this map must have--- the same kind. Also note that this map respects the distinction between--- @Type@ and @Constraint@, despite the fact that they are equivalent type--- synonyms in Core.-type TypeMapG = GenMap TypeMapX---- | @TypeMapX a@ is the base map from @DeBruijn Type@ to @a@, but without the--- 'GenMap' optimization.-data TypeMapX a-  = TM { tm_var    :: VarMap a-       , tm_app    :: TypeMapG (TypeMapG a)-       , tm_tycon  :: DNameEnv a-       , tm_forall :: TypeMapG (BndrMap a) -- See Note [Binders]-       , tm_tylit  :: TyLitMap a-       , tm_coerce :: Maybe a-       }-    -- Note that there is no tyconapp case; see Note [Equality on AppTys] in Type---- | Squeeze out any synonyms, and change TyConApps to nested AppTys. Why the--- last one? See Note [Equality on AppTys] in Type------ Note, however, that we keep Constraint and Type apart here, despite the fact--- that they are both synonyms of TYPE 'LiftedRep (see #11715).-trieMapView :: Type -> Maybe Type-trieMapView ty-  -- First check for TyConApps that need to be expanded to-  -- AppTy chains.-  | Just (tc, tys@(_:_)) <- tcSplitTyConApp_maybe ty-  = Just $ foldl' AppTy (TyConApp tc []) tys--  -- Then resolve any remaining nullary synonyms.-  | Just ty' <- tcView ty = Just ty'-trieMapView _ = Nothing--instance TrieMap TypeMapX where-   type Key TypeMapX = DeBruijn Type-   emptyTM  = emptyT-   lookupTM = lkT-   alterTM  = xtT-   foldTM   = fdT-   mapTM    = mapT--instance Eq (DeBruijn Type) where-  env_t@(D env t) == env_t'@(D env' t')-    | Just new_t  <- tcView t  = D env new_t == env_t'-    | Just new_t' <- tcView t' = env_t       == D env' new_t'-    | otherwise-    = case (t, t') of-        (CastTy t1 _, _)  -> D env t1 == D env t'-        (_, CastTy t1' _) -> D env t  == D env t1'--        (TyVarTy v, TyVarTy v')-            -> case (lookupCME env v, lookupCME env' v') of-                (Just bv, Just bv') -> bv == bv'-                (Nothing, Nothing)  -> v == v'-                _ -> False-                -- See Note [Equality on AppTys] in Type-        (AppTy t1 t2, s) | Just (t1', t2') <- repSplitAppTy_maybe s-            -> D env t1 == D env' t1' && D env t2 == D env' t2'-        (s, AppTy t1' t2') | Just (t1, t2) <- repSplitAppTy_maybe s-            -> D env t1 == D env' t1' && D env t2 == D env' t2'-        (FunTy _ t1 t2, FunTy _ t1' t2')-            -> D env t1 == D env' t1' && D env t2 == D env' t2'-        (TyConApp tc tys, TyConApp tc' tys')-            -> tc == tc' && D env tys == D env' tys'-        (LitTy l, LitTy l')-            -> l == l'-        (ForAllTy (Bndr tv _) ty, ForAllTy (Bndr tv' _) ty')-            -> D env (varType tv)      == D env' (varType tv') &&-               D (extendCME env tv) ty == D (extendCME env' tv') ty'-        (CoercionTy {}, CoercionTy {})-            -> True-        _ -> False--instance {-# OVERLAPPING #-}-         Outputable a => Outputable (TypeMapG a) where-  ppr m = text "TypeMap elts" <+> ppr (foldTM (:) m [])--emptyT :: TypeMapX a-emptyT = TM { tm_var  = emptyTM-            , tm_app  = emptyTM-            , tm_tycon  = emptyDNameEnv-            , tm_forall = emptyTM-            , tm_tylit  = emptyTyLitMap-            , tm_coerce = Nothing }--mapT :: (a->b) -> TypeMapX a -> TypeMapX b-mapT f (TM { tm_var  = tvar, tm_app = tapp, tm_tycon = ttycon-           , tm_forall = tforall, tm_tylit = tlit-           , tm_coerce = tcoerce })-  = TM { tm_var    = mapTM f tvar-       , tm_app    = mapTM (mapTM f) tapp-       , tm_tycon  = mapTM f ttycon-       , tm_forall = mapTM (mapTM f) tforall-       , tm_tylit  = mapTM f tlit-       , tm_coerce = fmap f tcoerce }--------------------lkT :: DeBruijn Type -> TypeMapX a -> Maybe a-lkT (D env ty) m = go ty m-  where-    go ty | Just ty' <- trieMapView ty = go ty'-    go (TyVarTy v)                 = tm_var    >.> lkVar env v-    go (AppTy t1 t2)               = tm_app    >.> lkG (D env t1)-                                               >=> lkG (D env t2)-    go (TyConApp tc [])            = tm_tycon  >.> lkDNamed tc-    go ty@(TyConApp _ (_:_))       = pprPanic "lkT TyConApp" (ppr ty)-    go (LitTy l)                   = tm_tylit  >.> lkTyLit l-    go (ForAllTy (Bndr tv _) ty)   = tm_forall >.> lkG (D (extendCME env tv) ty)-                                               >=> lkBndr env tv-    go ty@(FunTy {})               = pprPanic "lkT FunTy" (ppr ty)-    go (CastTy t _)                = go t-    go (CoercionTy {})             = tm_coerce--------------------xtT :: DeBruijn Type -> XT a -> TypeMapX a -> TypeMapX a-xtT (D env ty) f m | Just ty' <- trieMapView ty = xtT (D env ty') f m--xtT (D env (TyVarTy v))       f m = m { tm_var    = tm_var m |> xtVar env v f }-xtT (D env (AppTy t1 t2))     f m = m { tm_app    = tm_app m |> xtG (D env t1)-                                                            |>> xtG (D env t2) f }-xtT (D _   (TyConApp tc []))  f m = m { tm_tycon  = tm_tycon m |> xtDNamed tc f }-xtT (D _   (LitTy l))         f m = m { tm_tylit  = tm_tylit m |> xtTyLit l f }-xtT (D env (CastTy t _))      f m = xtT (D env t) f m-xtT (D _   (CoercionTy {}))   f m = m { tm_coerce = tm_coerce m |> f }-xtT (D env (ForAllTy (Bndr tv _) ty))  f m-  = m { tm_forall = tm_forall m |> xtG (D (extendCME env tv) ty)-                                |>> xtBndr env tv f }-xtT (D _   ty@(TyConApp _ (_:_))) _ _ = pprPanic "xtT TyConApp" (ppr ty)-xtT (D _   ty@(FunTy {}))         _ _ = pprPanic "xtT FunTy" (ppr ty)--fdT :: (a -> b -> b) -> TypeMapX a -> b -> b-fdT k m = foldTM k (tm_var m)-        . foldTM (foldTM k) (tm_app m)-        . foldTM k (tm_tycon m)-        . foldTM (foldTM k) (tm_forall m)-        . foldTyLit k (tm_tylit m)-        . foldMaybe k (tm_coerce m)---------------------------data TyLitMap a = TLM { tlm_number :: Map.Map Integer a-                      , tlm_string :: Map.Map FastString a-                      }--instance TrieMap TyLitMap where-   type Key TyLitMap = TyLit-   emptyTM  = emptyTyLitMap-   lookupTM = lkTyLit-   alterTM  = xtTyLit-   foldTM   = foldTyLit-   mapTM    = mapTyLit--emptyTyLitMap :: TyLitMap a-emptyTyLitMap = TLM { tlm_number = Map.empty, tlm_string = Map.empty }--mapTyLit :: (a->b) -> TyLitMap a -> TyLitMap b-mapTyLit f (TLM { tlm_number = tn, tlm_string = ts })-  = TLM { tlm_number = Map.map f tn, tlm_string = Map.map f ts }--lkTyLit :: TyLit -> TyLitMap a -> Maybe a-lkTyLit l =-  case l of-    NumTyLit n -> tlm_number >.> Map.lookup n-    StrTyLit n -> tlm_string >.> Map.lookup n--xtTyLit :: TyLit -> XT a -> TyLitMap a -> TyLitMap a-xtTyLit l f m =-  case l of-    NumTyLit n -> m { tlm_number = tlm_number m |> Map.alter f n }-    StrTyLit n -> m { tlm_string = tlm_string m |> Map.alter f n }--foldTyLit :: (a -> b -> b) -> TyLitMap a -> b -> b-foldTyLit l m = flip (Map.foldr l) (tlm_string m)-              . flip (Map.foldr l) (tlm_number m)------------------------------------------------------ | @TypeMap a@ is a map from 'Type' to @a@.  If you are a client, this--- is the type you want. The keys in this map may have different kinds.-newtype TypeMap a = TypeMap (TypeMapG (TypeMapG a))--lkTT :: DeBruijn Type -> TypeMap a -> Maybe a-lkTT (D env ty) (TypeMap m) = lkG (D env $ typeKind ty) m-                          >>= lkG (D env ty)--xtTT :: DeBruijn Type -> XT a -> TypeMap a -> TypeMap a-xtTT (D env ty) f (TypeMap m)-  = TypeMap (m |> xtG (D env $ typeKind ty)-               |>> xtG (D env ty) f)---- Below are some client-oriented functions which operate on 'TypeMap'.--instance TrieMap TypeMap where-    type Key TypeMap = Type-    emptyTM = TypeMap emptyTM-    lookupTM k m = lkTT (deBruijnize k) m-    alterTM k f m = xtTT (deBruijnize k) f m-    foldTM k (TypeMap m) = foldTM (foldTM k) m-    mapTM f (TypeMap m) = TypeMap (mapTM (mapTM f) m)--foldTypeMap :: (a -> b -> b) -> b -> TypeMap a -> b-foldTypeMap k z m = foldTM k m z--emptyTypeMap :: TypeMap a-emptyTypeMap = emptyTM--lookupTypeMap :: TypeMap a -> Type -> Maybe a-lookupTypeMap cm t = lookupTM t cm--extendTypeMap :: TypeMap a -> Type -> a -> TypeMap a-extendTypeMap m t v = alterTM t (const (Just v)) m--lookupTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> Maybe a-lookupTypeMapWithScope m cm t = lkTT (D cm t) m---- | Extend a 'TypeMap' with a type in the given context.--- @extendTypeMapWithScope m (mkDeBruijnContext [a,b,c]) t v@ is equivalent to--- @extendTypeMap m (forall a b c. t) v@, but allows reuse of the context over--- multiple insertions.-extendTypeMapWithScope :: TypeMap a -> CmEnv -> Type -> a -> TypeMap a-extendTypeMapWithScope m cm t v = xtTT (D cm t) (const (Just v)) m---- | Construct a deBruijn environment with the given variables in scope.--- e.g. @mkDeBruijnEnv [a,b,c]@ constructs a context @forall a b c.@-mkDeBruijnContext :: [Var] -> CmEnv-mkDeBruijnContext = extendCMEs emptyCME---- | A 'LooseTypeMap' doesn't do a kind-check. Thus, when lookup up (t |> g),--- you'll find entries inserted under (t), even if (g) is non-reflexive.-newtype LooseTypeMap a-  = LooseTypeMap (TypeMapG a)--instance TrieMap LooseTypeMap where-  type Key LooseTypeMap = Type-  emptyTM = LooseTypeMap emptyTM-  lookupTM k (LooseTypeMap m) = lookupTM (deBruijnize k) m-  alterTM k f (LooseTypeMap m) = LooseTypeMap (alterTM (deBruijnize k) f m)-  foldTM f (LooseTypeMap m) = foldTM f m-  mapTM f (LooseTypeMap m) = LooseTypeMap (mapTM f m)--{--************************************************************************-*                                                                      *-                   Variables-*                                                                      *-************************************************************************--}--type BoundVar = Int  -- Bound variables are deBruijn numbered-type BoundVarMap a = IntMap.IntMap a--data CmEnv = CME { cme_next :: !BoundVar-                 , cme_env  :: VarEnv BoundVar }--emptyCME :: CmEnv-emptyCME = CME { cme_next = 0, cme_env = emptyVarEnv }--extendCME :: CmEnv -> Var -> CmEnv-extendCME (CME { cme_next = bv, cme_env = env }) v-  = CME { cme_next = bv+1, cme_env = extendVarEnv env v bv }--extendCMEs :: CmEnv -> [Var] -> CmEnv-extendCMEs env vs = foldl' extendCME env vs--lookupCME :: CmEnv -> Var -> Maybe BoundVar-lookupCME (CME { cme_env = env }) v = lookupVarEnv env v---- | @DeBruijn a@ represents @a@ modulo alpha-renaming.  This is achieved--- by equipping the value with a 'CmEnv', which tracks an on-the-fly deBruijn--- numbering.  This allows us to define an 'Eq' instance for @DeBruijn a@, even--- if this was not (easily) possible for @a@.  Note: we purposely don't--- export the constructor.  Make a helper function if you find yourself--- needing it.-data DeBruijn a = D CmEnv a---- | Synthesizes a @DeBruijn a@ from an @a@, by assuming that there are no--- bound binders (an empty 'CmEnv').  This is usually what you want if there--- isn't already a 'CmEnv' in scope.-deBruijnize :: a -> DeBruijn a-deBruijnize = D emptyCME--instance Eq (DeBruijn a) => Eq (DeBruijn [a]) where-    D _   []     == D _    []       = True-    D env (x:xs) == D env' (x':xs') = D env x  == D env' x' &&-                                      D env xs == D env' xs'-    _            == _               = False----------- Variable binders ----------------- | A 'BndrMap' is a 'TypeMapG' which allows us to distinguish between--- binding forms whose binders have different types.  For example,--- if we are doing a 'TrieMap' lookup on @\(x :: Int) -> ()@, we should--- not pick up an entry in the 'TrieMap' for @\(x :: Bool) -> ()@:--- we can disambiguate this by matching on the type (or kind, if this--- a binder in a type) of the binder.-type BndrMap = TypeMapG---- Note [Binders]--- ~~~~~~~~~~~~~~--- We need to use 'BndrMap' for 'Coercion', 'CoreExpr' AND 'Type', since all--- of these data types have binding forms.--lkBndr :: CmEnv -> Var -> BndrMap a -> Maybe a-lkBndr env v m = lkG (D env (varType v)) m--xtBndr :: CmEnv -> Var -> XT a -> BndrMap a -> BndrMap a-xtBndr env v f = xtG (D env (varType v)) f----------- Variable occurrence --------------data VarMap a = VM { vm_bvar   :: BoundVarMap a  -- Bound variable-                   , vm_fvar   :: DVarEnv a }      -- Free variable--instance TrieMap VarMap where-   type Key VarMap = Var-   emptyTM  = VM { vm_bvar = IntMap.empty, vm_fvar = emptyDVarEnv }-   lookupTM = lkVar emptyCME-   alterTM  = xtVar emptyCME-   foldTM   = fdVar-   mapTM    = mapVar--mapVar :: (a->b) -> VarMap a -> VarMap b-mapVar f (VM { vm_bvar = bv, vm_fvar = fv })-  = VM { vm_bvar = mapTM f bv, vm_fvar = mapTM f fv }--lkVar :: CmEnv -> Var -> VarMap a -> Maybe a-lkVar env v-  | Just bv <- lookupCME env v = vm_bvar >.> lookupTM bv-  | otherwise                  = vm_fvar >.> lkDFreeVar v--xtVar :: CmEnv -> Var -> XT a -> VarMap a -> VarMap a-xtVar env v f m-  | Just bv <- lookupCME env v = m { vm_bvar = vm_bvar m |> alterTM bv f }-  | otherwise                  = m { vm_fvar = vm_fvar m |> xtDFreeVar v f }--fdVar :: (a -> b -> b) -> VarMap a -> b -> b-fdVar k m = foldTM k (vm_bvar m)-          . foldTM k (vm_fvar m)--lkDFreeVar :: Var -> DVarEnv a -> Maybe a-lkDFreeVar var env = lookupDVarEnv env var--xtDFreeVar :: Var -> XT a -> DVarEnv a -> DVarEnv a-xtDFreeVar v f m = alterDVarEnv f m v

− compiler/coreSyn/CoreOpt.hs

@@ -1,1475 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--}--{-# LANGUAGE CPP #-}-module CoreOpt (-        -- ** Simple expression optimiser-        simpleOptPgm, simpleOptExpr, simpleOptExprWith,--        -- ** Join points-        joinPointBinding_maybe, joinPointBindings_maybe,--        -- ** Predicates on expressions-        exprIsConApp_maybe, exprIsLiteral_maybe, exprIsLambda_maybe,--        -- ** Coercions and casts-        pushCoArg, pushCoValArg, pushCoTyArg, collectBindersPushingCo-    ) where--#include "HsVersions.h"--import GhcPrelude--import CoreArity( etaExpandToJoinPoint )--import CoreSyn-import CoreSubst-import CoreUtils-import CoreFVs-import {-#SOURCE #-} CoreUnfold ( mkUnfolding )-import MkCore ( FloatBind(..) )-import PprCore  ( pprCoreBindings, pprRules )-import OccurAnal( occurAnalyseExpr, occurAnalysePgm )-import Literal  ( Literal(LitString) )-import Id-import IdInfo   ( unfoldingInfo, setUnfoldingInfo, setRuleInfo, IdInfo (..) )-import Var      ( isNonCoVarId )-import VarSet-import VarEnv-import DataCon-import Demand( etaExpandStrictSig )-import OptCoercion ( optCoercion )-import Type     hiding ( substTy, extendTvSubst, extendCvSubst, extendTvSubstList-                       , isInScope, substTyVarBndr, cloneTyVarBndr )-import Coercion hiding ( substCo, substCoVarBndr )-import TyCon        ( tyConArity )-import TysWiredIn-import PrelNames-import BasicTypes-import Module       ( Module )-import ErrUtils-import DynFlags-import Outputable-import Pair-import Util-import Maybes       ( orElse )-import FastString-import Data.List-import qualified Data.ByteString as BS--{--************************************************************************-*                                                                      *-        The Simple Optimiser-*                                                                      *-************************************************************************--Note [The simple optimiser]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-The simple optimiser is a lightweight, pure (non-monadic) function-that rapidly does a lot of simple optimisations, including--  - inlining things that occur just once,-      or whose RHS turns out to be trivial-  - beta reduction-  - case of known constructor-  - dead code elimination--It does NOT do any call-site inlining; it only inlines a function if-it can do so unconditionally, dropping the binding.  It thereby-guarantees to leave no un-reduced beta-redexes.--It is careful to follow the guidance of "Secrets of the GHC inliner",-and in particular the pre-inline-unconditionally and-post-inline-unconditionally story, to do effective beta reduction on-functions called precisely once, without repeatedly optimising the same-expression.  In fact, the simple optimiser is a good example of this-little dance in action; the full Simplifier is a lot more complicated.---}--simpleOptExpr :: DynFlags -> CoreExpr -> CoreExpr--- See Note [The simple optimiser]--- Do simple optimisation on an expression--- The optimisation is very straightforward: just--- inline non-recursive bindings that are used only once,--- or where the RHS is trivial------ We also inline bindings that bind a Eq# box: see--- See Note [Getting the map/coerce RULE to work].------ Also we convert functions to join points where possible (as--- the occurrence analyser does most of the work anyway).------ The result is NOT guaranteed occurrence-analysed, because--- in  (let x = y in ....) we substitute for x; so y's occ-info--- may change radically--simpleOptExpr dflags expr-  = -- pprTrace "simpleOptExpr" (ppr init_subst $$ ppr expr)-    simpleOptExprWith dflags init_subst expr-  where-    init_subst = mkEmptySubst (mkInScopeSet (exprFreeVars expr))-        -- It's potentially important to make a proper in-scope set-        -- Consider  let x = ..y.. in \y. ...x...-        -- Then we should remember to clone y before substituting-        -- for x.  It's very unlikely to occur, because we probably-        -- won't *be* substituting for x if it occurs inside a-        -- lambda.-        ---        -- It's a bit painful to call exprFreeVars, because it makes-        -- three passes instead of two (occ-anal, and go)--simpleOptExprWith :: DynFlags -> Subst -> InExpr -> OutExpr--- See Note [The simple optimiser]-simpleOptExprWith dflags subst expr-  = simple_opt_expr init_env (occurAnalyseExpr expr)-  where-    init_env = SOE { soe_dflags = dflags-                   , soe_inl = emptyVarEnv-                   , soe_subst = subst }-------------------------simpleOptPgm :: DynFlags -> Module-             -> CoreProgram -> [CoreRule]-             -> IO (CoreProgram, [CoreRule])--- See Note [The simple optimiser]-simpleOptPgm dflags this_mod binds rules-  = do { dumpIfSet_dyn dflags Opt_D_dump_occur_anal "Occurrence analysis"-            FormatCore (pprCoreBindings occ_anald_binds $$ pprRules rules );--       ; return (reverse binds', rules') }-  where-    occ_anald_binds  = occurAnalysePgm this_mod-                          (\_ -> True)  {- All unfoldings active -}-                          (\_ -> False) {- No rules active -}-                          rules binds--    (final_env, binds') = foldl' do_one (emptyEnv dflags, []) occ_anald_binds-    final_subst = soe_subst final_env--    rules' = substRulesForImportedIds final_subst rules-             -- We never unconditionally inline into rules,-             -- hence paying just a substitution--    do_one (env, binds') bind-      = case simple_opt_bind env bind TopLevel of-          (env', Nothing)    -> (env', binds')-          (env', Just bind') -> (env', bind':binds')---- In these functions the substitution maps InVar -> OutExpr-------------------------type SimpleClo = (SimpleOptEnv, InExpr)--data SimpleOptEnv-  = SOE { soe_dflags :: DynFlags-        , soe_inl   :: IdEnv SimpleClo-             -- Deals with preInlineUnconditionally; things-             -- that occur exactly once and are inlined-             -- without having first been simplified--        , soe_subst :: Subst-             -- Deals with cloning; includes the InScopeSet-        }--instance Outputable SimpleOptEnv where-  ppr (SOE { soe_inl = inl, soe_subst = subst })-    = text "SOE {" <+> vcat [ text "soe_inl   =" <+> ppr inl-                            , text "soe_subst =" <+> ppr subst ]-                   <+> text "}"--emptyEnv :: DynFlags -> SimpleOptEnv-emptyEnv dflags-  = SOE { soe_dflags = dflags-        , soe_inl = emptyVarEnv-        , soe_subst = emptySubst }--soeZapSubst :: SimpleOptEnv -> SimpleOptEnv-soeZapSubst env@(SOE { soe_subst = subst })-  = env { soe_inl = emptyVarEnv, soe_subst = zapSubstEnv subst }--soeSetInScope :: SimpleOptEnv -> SimpleOptEnv -> SimpleOptEnv--- Take in-scope set from env1, and the rest from env2-soeSetInScope (SOE { soe_subst = subst1 })-              env2@(SOE { soe_subst = subst2 })-  = env2 { soe_subst = setInScope subst2 (substInScope subst1) }------------------simple_opt_clo :: SimpleOptEnv -> SimpleClo -> OutExpr-simple_opt_clo env (e_env, e)-  = simple_opt_expr (soeSetInScope env e_env) e--simple_opt_expr :: HasCallStack => SimpleOptEnv -> InExpr -> OutExpr-simple_opt_expr env expr-  = go expr-  where-    subst        = soe_subst env-    in_scope     = substInScope subst-    in_scope_env = (in_scope, simpleUnfoldingFun)--    go (Var v)-       | Just clo <- lookupVarEnv (soe_inl env) v-       = simple_opt_clo env clo-       | otherwise-       = lookupIdSubst (text "simpleOptExpr") (soe_subst env) v--    go (App e1 e2)      = simple_app env e1 [(env,e2)]-    go (Type ty)        = Type     (substTy subst ty)-    go (Coercion co)    = Coercion (optCoercion (soe_dflags env) (getTCvSubst subst) co)-    go (Lit lit)        = Lit lit-    go (Tick tickish e) = mkTick (substTickish subst tickish) (go e)-    go (Cast e co)      | isReflCo co' = go e-                        | otherwise    = Cast (go e) co'-                        where-                          co' = optCoercion (soe_dflags env) (getTCvSubst subst) co--    go (Let bind body)  = case simple_opt_bind env bind NotTopLevel of-                             (env', Nothing)   -> simple_opt_expr env' body-                             (env', Just bind) -> Let bind (simple_opt_expr env' body)--    go lam@(Lam {})     = go_lam env [] lam-    go (Case e b ty as)-       -- See Note [Getting the map/coerce RULE to work]-      | isDeadBinder b-      , Just (_, [], con, _tys, es) <- exprIsConApp_maybe in_scope_env e'-        -- We don't need to be concerned about floats when looking for coerce.-      , Just (altcon, bs, rhs) <- findAlt (DataAlt con) as-      = case altcon of-          DEFAULT -> go rhs-          _       -> foldr wrapLet (simple_opt_expr env' rhs) mb_prs-            where-              (env', mb_prs) = mapAccumL (simple_out_bind NotTopLevel) env $-                               zipEqual "simpleOptExpr" bs es--         -- Note [Getting the map/coerce RULE to work]-      | isDeadBinder b-      , [(DEFAULT, _, rhs)] <- as-      , isCoVarType (varType b)-      , (Var fun, _args) <- collectArgs e-      , fun `hasKey` coercibleSCSelIdKey-         -- without this last check, we get #11230-      = go rhs--      | otherwise-      = Case e' b' (substTy subst ty)-                   (map (go_alt env') as)-      where-        e' = go e-        (env', b') = subst_opt_bndr env b--    -----------------------    go_alt env (con, bndrs, rhs)-      = (con, bndrs', simple_opt_expr env' rhs)-      where-        (env', bndrs') = subst_opt_bndrs env bndrs--    -----------------------    -- go_lam tries eta reduction-    go_lam env bs' (Lam b e)-       = go_lam env' (b':bs') e-       where-         (env', b') = subst_opt_bndr env b-    go_lam env bs' e-       | Just etad_e <- tryEtaReduce bs e' = etad_e-       | otherwise                         = mkLams bs e'-       where-         bs = reverse bs'-         e' = simple_opt_expr env e--------------------------- simple_app collects arguments for beta reduction-simple_app :: SimpleOptEnv -> InExpr -> [SimpleClo] -> CoreExpr--simple_app env (Var v) as-  | Just (env', e) <- lookupVarEnv (soe_inl env) v-  = simple_app (soeSetInScope env env') e as--  | let unf = idUnfolding v-  , isCompulsoryUnfolding (idUnfolding v)-  , isAlwaysActive (idInlineActivation v)-    -- See Note [Unfold compulsory unfoldings in LHSs]-  = simple_app (soeZapSubst env) (unfoldingTemplate unf) as--  | otherwise-  , let out_fn = lookupIdSubst (text "simple_app") (soe_subst env) v-  = finish_app env out_fn as--simple_app env (App e1 e2) as-  = simple_app env e1 ((env, e2) : as)--simple_app env (Lam b e) (a:as)-  = wrapLet mb_pr (simple_app env' e as)-  where-     (env', mb_pr) = simple_bind_pair env b Nothing a NotTopLevel--simple_app env (Tick t e) as-  -- Okay to do "(Tick t e) x ==> Tick t (e x)"?-  | t `tickishScopesLike` SoftScope-  = mkTick t $ simple_app env e as---- (let x = e in b) a1 .. an  =>  let x = e in (b a1 .. an)--- The let might appear there as a result of inlining--- e.g.   let f = let x = e in b---        in f a1 a2---   (#13208)--- However, do /not/ do this transformation for join points---    See Note [simple_app and join points]-simple_app env (Let bind body) args-  = case simple_opt_bind env bind NotTopLevel of-      (env', Nothing)   -> simple_app env' body args-      (env', Just bind')-        | isJoinBind bind' -> finish_app env expr' args-        | otherwise        -> Let bind' (simple_app env' body args)-        where-          expr' = Let bind' (simple_opt_expr env' body)--simple_app env e as-  = finish_app env (simple_opt_expr env e) as--finish_app :: SimpleOptEnv -> OutExpr -> [SimpleClo] -> OutExpr-finish_app _ fun []-  = fun-finish_app env fun (arg:args)-  = finish_app env (App fun (simple_opt_clo env arg)) args-------------------------simple_opt_bind :: SimpleOptEnv -> InBind -> TopLevelFlag-                -> (SimpleOptEnv, Maybe OutBind)-simple_opt_bind env (NonRec b r) top_level-  = (env', case mb_pr of-            Nothing    -> Nothing-            Just (b,r) -> Just (NonRec b r))-  where-    (b', r') = joinPointBinding_maybe b r `orElse` (b, r)-    (env', mb_pr) = simple_bind_pair env b' Nothing (env,r') top_level--simple_opt_bind env (Rec prs) top_level-  = (env'', res_bind)-  where-    res_bind          = Just (Rec (reverse rev_prs'))-    prs'              = joinPointBindings_maybe prs `orElse` prs-    (env', bndrs')    = subst_opt_bndrs env (map fst prs')-    (env'', rev_prs') = foldl' do_pr (env', []) (prs' `zip` bndrs')-    do_pr (env, prs) ((b,r), b')-       = (env', case mb_pr of-                  Just pr -> pr : prs-                  Nothing -> prs)-       where-         (env', mb_pr) = simple_bind_pair env b (Just b') (env,r) top_level-------------------------simple_bind_pair :: SimpleOptEnv-                 -> InVar -> Maybe OutVar-                 -> SimpleClo-                 -> TopLevelFlag-                 -> (SimpleOptEnv, Maybe (OutVar, OutExpr))-    -- (simple_bind_pair subst in_var out_rhs)-    --   either extends subst with (in_var -> out_rhs)-    --   or     returns Nothing-simple_bind_pair env@(SOE { soe_inl = inl_env, soe_subst = subst })-                 in_bndr mb_out_bndr clo@(rhs_env, in_rhs)-                 top_level-  | Type ty <- in_rhs        -- let a::* = TYPE ty in <body>-  , let out_ty = substTy (soe_subst rhs_env) ty-  = ASSERT( isTyVar in_bndr )-    (env { soe_subst = extendTvSubst subst in_bndr out_ty }, Nothing)--  | Coercion co <- in_rhs-  , let out_co = optCoercion (soe_dflags env) (getTCvSubst (soe_subst rhs_env)) co-  = ASSERT( isCoVar in_bndr )-    (env { soe_subst = extendCvSubst subst in_bndr out_co }, Nothing)--  | ASSERT2( isNonCoVarId in_bndr, ppr in_bndr )-    -- The previous two guards got rid of tyvars and coercions-    -- See Note [CoreSyn type and coercion invariant] in CoreSyn-    pre_inline_unconditionally-  = (env { soe_inl = extendVarEnv inl_env in_bndr clo }, Nothing)--  | otherwise-  = simple_out_bind_pair env in_bndr mb_out_bndr out_rhs-                         occ active stable_unf top_level-  where-    stable_unf = isStableUnfolding (idUnfolding in_bndr)-    active     = isAlwaysActive (idInlineActivation in_bndr)-    occ        = idOccInfo in_bndr--    out_rhs | Just join_arity <- isJoinId_maybe in_bndr-            = simple_join_rhs join_arity-            | otherwise-            = simple_opt_clo env clo--    simple_join_rhs join_arity -- See Note [Preserve join-binding arity]-      = mkLams join_bndrs' (simple_opt_expr env_body join_body)-      where-        env0 = soeSetInScope env rhs_env-        (join_bndrs, join_body) = collectNBinders join_arity in_rhs-        (env_body, join_bndrs') = subst_opt_bndrs env0 join_bndrs--    pre_inline_unconditionally :: Bool-    pre_inline_unconditionally-       | isExportedId in_bndr     = False-       | stable_unf               = False-       | not active               = False    -- Note [Inline prag in simplOpt]-       | not (safe_to_inline occ) = False-       | otherwise                = True--        -- Unconditionally safe to inline-    safe_to_inline :: OccInfo -> Bool-    safe_to_inline IAmALoopBreaker{}                  = False-    safe_to_inline IAmDead                            = True-    safe_to_inline OneOcc{ occ_in_lam = NotInsideLam-                         , occ_one_br = InOneBranch } = True-    safe_to_inline OneOcc{}                           = False-    safe_to_inline ManyOccs{}                         = False----------------------simple_out_bind :: TopLevelFlag-                -> SimpleOptEnv-                -> (InVar, OutExpr)-                -> (SimpleOptEnv, Maybe (OutVar, OutExpr))-simple_out_bind top_level env@(SOE { soe_subst = subst }) (in_bndr, out_rhs)-  | Type out_ty <- out_rhs-  = ASSERT( isTyVar in_bndr )-    (env { soe_subst = extendTvSubst subst in_bndr out_ty }, Nothing)--  | Coercion out_co <- out_rhs-  = ASSERT( isCoVar in_bndr )-    (env { soe_subst = extendCvSubst subst in_bndr out_co }, Nothing)--  | otherwise-  = simple_out_bind_pair env in_bndr Nothing out_rhs-                         (idOccInfo in_bndr) True False top_level----------------------simple_out_bind_pair :: SimpleOptEnv-                     -> InId -> Maybe OutId -> OutExpr-                     -> OccInfo -> Bool -> Bool -> TopLevelFlag-                     -> (SimpleOptEnv, Maybe (OutVar, OutExpr))-simple_out_bind_pair env in_bndr mb_out_bndr out_rhs-                     occ_info active stable_unf top_level-  | ASSERT2( isNonCoVarId in_bndr, ppr in_bndr )-    -- Type and coercion bindings are caught earlier-    -- See Note [CoreSyn type and coercion invariant]-    post_inline_unconditionally-  = ( env' { soe_subst = extendIdSubst (soe_subst env) in_bndr out_rhs }-    , Nothing)--  | otherwise-  = ( env', Just (out_bndr, out_rhs) )-  where-    (env', bndr1) = case mb_out_bndr of-                      Just out_bndr -> (env, out_bndr)-                      Nothing       -> subst_opt_bndr env in_bndr-    out_bndr = add_info env' in_bndr top_level out_rhs bndr1--    post_inline_unconditionally :: Bool-    post_inline_unconditionally-       | isExportedId in_bndr  = False -- Note [Exported Ids and trivial RHSs]-       | stable_unf            = False -- Note [Stable unfoldings and postInlineUnconditionally]-       | not active            = False --     in SimplUtils-       | is_loop_breaker       = False -- If it's a loop-breaker of any kind, don't inline-                                       -- because it might be referred to "earlier"-       | exprIsTrivial out_rhs = True-       | coercible_hack        = True-       | otherwise             = False--    is_loop_breaker = isWeakLoopBreaker occ_info--    -- See Note [Getting the map/coerce RULE to work]-    coercible_hack | (Var fun, args) <- collectArgs out_rhs-                   , Just dc <- isDataConWorkId_maybe fun-                   , dc `hasKey` heqDataConKey || dc `hasKey` coercibleDataConKey-                   = all exprIsTrivial args-                   | otherwise-                   = False--{- Note [Exported Ids and trivial RHSs]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We obviously do not want to unconditionally inline an Id that is exported.-In SimplUtils, Note [Top level and postInlineUnconditionally], we-explain why we don't inline /any/ top-level things unconditionally, even-trivial ones.  But we do here!  Why?  In the simple optimiser--  * We do no rule rewrites-  * We do no call-site inlining--Those differences obviate the reasons for not inlining a trivial rhs,-and increase the benefit for doing so.  So we unconditionally inline trivial-rhss here.--Note [Preserve join-binding arity]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Be careful /not/ to eta-reduce the RHS of a join point, lest we lose-the join-point arity invariant.  #15108 was caused by simplifying-the RHS with simple_opt_expr, which does eta-reduction.  Solution:-simplify the RHS of a join point by simplifying under the lambdas-(which of course should be there).--Note [simple_app and join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In general for let-bindings we can do this:-   (let { x = e } in b) a  ==>  let { x = e } in b a--But not for join points!  For two reasons:--- We would need to push the continuation into the RHS:-   (join { j = e } in b) a  ==>  let { j' = e a } in b[j'/j] a-                                      NB ----^^-  and also change the type of j, hence j'.-  That's a bit sophisticated for the very simple optimiser.--- We might end up with something like-    join { j' = e a } in-    (case blah of        )-    (  True  -> j' void# ) a-    (  False -> blah     )-  and now the call to j' doesn't look like a tail call, and-  Lint may reject.  I say "may" because this is /explicitly/-  allowed in the "Compiling without Continuations" paper-  (Section 3, "Managing \Delta").  But GHC currently does not-  allow this slightly-more-flexible form.  See CoreSyn-  Note [Join points are less general than the paper].--The simple thing to do is to disable this transformation-for join points in the simple optimiser--Note [The Let-Unfoldings Invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A program has the Let-Unfoldings property iff:--- For every let-bound variable f, whether top-level or nested, whether-  recursive or not:-  - Both the binding Id of f, and every occurrence Id of f, has an idUnfolding.-  - For non-INLINE things, that unfolding will be f's right hand sids-  - For INLINE things (which have a "stable" unfolding) that unfolding is-    semantically equivalent to f's RHS, but derived from the original RHS of f-    rather that its current RHS.--Informally, we can say that in a program that has the Let-Unfoldings property,-all let-bound Id's have an explicit unfolding attached to them.--Currently, the simplifier guarantees the Let-Unfoldings invariant for anything-it outputs.---}-------------------------subst_opt_bndrs :: SimpleOptEnv -> [InVar] -> (SimpleOptEnv, [OutVar])-subst_opt_bndrs env bndrs = mapAccumL subst_opt_bndr env bndrs--subst_opt_bndr :: SimpleOptEnv -> InVar -> (SimpleOptEnv, OutVar)-subst_opt_bndr env bndr-  | isTyVar bndr  = (env { soe_subst = subst_tv }, tv')-  | isCoVar bndr  = (env { soe_subst = subst_cv }, cv')-  | otherwise     = subst_opt_id_bndr env bndr-  where-    subst           = soe_subst env-    (subst_tv, tv') = substTyVarBndr subst bndr-    (subst_cv, cv') = substCoVarBndr subst bndr--subst_opt_id_bndr :: SimpleOptEnv -> InId -> (SimpleOptEnv, OutId)--- Nuke all fragile IdInfo, unfolding, and RULES; it gets added back later by--- add_info.------ Rather like SimplEnv.substIdBndr------ It's important to zap fragile OccInfo (which CoreSubst.substIdBndr--- carefully does not do) because simplOptExpr invalidates it--subst_opt_id_bndr env@(SOE { soe_subst = subst, soe_inl = inl }) old_id-  = (env { soe_subst = new_subst, soe_inl = new_inl }, new_id)-  where-    Subst in_scope id_subst tv_subst cv_subst = subst--    id1    = uniqAway in_scope old_id-    id2    = setIdType id1 (substTy subst (idType old_id))-    new_id = zapFragileIdInfo id2-             -- 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--    no_change = new_id == old_id--        -- Extend the substitution if the unique has changed,-        -- See the notes with substTyVarBndr for the delSubstEnv-    new_id_subst-      | no_change = delVarEnv id_subst old_id-      | otherwise = extendVarEnv id_subst old_id (Var new_id)--    new_subst = Subst new_in_scope new_id_subst tv_subst cv_subst-    new_inl   = delVarEnv inl old_id-------------------------add_info :: SimpleOptEnv -> InVar -> TopLevelFlag -> OutExpr -> OutVar -> OutVar-add_info env old_bndr top_level new_rhs new_bndr- | isTyVar old_bndr = new_bndr- | otherwise        = lazySetIdInfo new_bndr new_info- where-   subst    = soe_subst env-   dflags   = soe_dflags env-   old_info = idInfo old_bndr--   -- Add back in the rules and unfolding which were-   -- removed by zapFragileIdInfo in subst_opt_id_bndr.-   ---   -- See Note [The Let-Unfoldings Invariant]-   new_info = idInfo new_bndr `setRuleInfo`      new_rules-                              `setUnfoldingInfo` new_unfolding--   old_rules = ruleInfo old_info-   new_rules = substSpec subst new_bndr old_rules--   old_unfolding = unfoldingInfo old_info-   new_unfolding | isStableUnfolding old_unfolding-                 = substUnfolding subst old_unfolding-                 | otherwise-                 = unfolding_from_rhs--   unfolding_from_rhs = mkUnfolding dflags InlineRhs-                                    (isTopLevel top_level)-                                    False -- may be bottom or not-                                    new_rhs--simpleUnfoldingFun :: IdUnfoldingFun-simpleUnfoldingFun id-  | isAlwaysActive (idInlineActivation id) = idUnfolding id-  | otherwise                              = noUnfolding--wrapLet :: Maybe (Id,CoreExpr) -> CoreExpr -> CoreExpr-wrapLet Nothing      body = body-wrapLet (Just (b,r)) body = Let (NonRec b r) body--{--Note [Inline prag in simplOpt]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If there's an INLINE/NOINLINE pragma that restricts the phase in-which the binder can be inlined, we don't inline here; after all,-we don't know what phase we're in.  Here's an example--  foo :: Int -> Int -> Int-  {-# INLINE foo #-}-  foo m n = inner m-     where-       {-# INLINE [1] inner #-}-       inner m = m+n--  bar :: Int -> Int-  bar n = foo n 1--When inlining 'foo' in 'bar' we want the let-binding for 'inner'-to remain visible until Phase 1--Note [Unfold compulsory unfoldings in LHSs]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When the user writes `RULES map coerce = coerce` as a rule, the rule-will only ever match if simpleOptExpr replaces coerce by its unfolding-on the LHS, because that is the core that the rule matching engine-will find. So do that for everything that has a compulsory-unfolding. Also see Note [Desugaring coerce as cast] in Desugar.--However, we don't want to inline 'seq', which happens to also have a-compulsory unfolding, so we only do this unfolding only for things-that are always-active.  See Note [User-defined RULES for seq] in MkId.--Note [Getting the map/coerce RULE to work]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We wish to allow the "map/coerce" RULE to fire:--  {-# RULES "map/coerce" map coerce = coerce #-}--The naive core produced for this is--  forall a b (dict :: Coercible * a b).-    map @a @b (coerce @a @b @dict) = coerce @[a] @[b] @dict'--  where dict' :: Coercible [a] [b]-        dict' = ...--This matches literal uses of `map coerce` in code, but that's not what we-want. We want it to match, say, `map MkAge` (where newtype Age = MkAge Int)-too. Some of this is addressed by compulsorily unfolding coerce on the LHS,-yielding--  forall a b (dict :: Coercible * a b).-    map @a @b (\(x :: a) -> case dict of-      MkCoercible (co :: a ~R# b) -> x |> co) = ...--Getting better. But this isn't exactly what gets produced. This is because-Coercible essentially has ~R# as a superclass, and superclasses get eagerly-extracted during solving. So we get this:--  forall a b (dict :: Coercible * a b).-    case Coercible_SCSel @* @a @b dict of-      _ [Dead] -> map @a @b (\(x :: a) -> case dict of-                               MkCoercible (co :: a ~R# b) -> x |> co) = ...--Unfortunately, this still abstracts over a Coercible dictionary. We really-want it to abstract over the ~R# evidence. So, we have Desugar.unfold_coerce,-which transforms the above to (see also Note [Desugaring coerce as cast] in-Desugar)--  forall a b (co :: a ~R# b).-    let dict = MkCoercible @* @a @b co in-    case Coercible_SCSel @* @a @b dict of-      _ [Dead] -> map @a @b (\(x :: a) -> case dict of-         MkCoercible (co :: a ~R# b) -> x |> co) = let dict = ... in ...--Now, we need simpleOptExpr to fix this up. It does so by taking three-separate actions:-  1. Inline certain non-recursive bindings. The choice whether to inline-     is made in simple_bind_pair. Note the rather specific check for-     MkCoercible in there.--  2. Stripping case expressions like the Coercible_SCSel one.-     See the `Case` case of simple_opt_expr's `go` function.--  3. Look for case expressions that unpack something that was-     just packed and inline them. This is also done in simple_opt_expr's-     `go` function.--This is all a fair amount of special-purpose hackery, but it's for-a good cause. And it won't hurt other RULES and such that it comes across.---************************************************************************-*                                                                      *-                Join points-*                                                                      *-************************************************************************--}---- | Returns Just (bndr,rhs) if the binding is a join point:--- If it's a JoinId, just return it--- If it's not yet a JoinId but is always tail-called,---    make it into a JoinId and return it.--- In the latter case, eta-expand the RHS if necessary, to make the--- lambdas explicit, as is required for join points------ Precondition: the InBndr has been occurrence-analysed,---               so its OccInfo is valid-joinPointBinding_maybe :: InBndr -> InExpr -> Maybe (InBndr, InExpr)-joinPointBinding_maybe bndr rhs-  | not (isId bndr)-  = Nothing--  | isJoinId bndr-  = Just (bndr, rhs)--  | AlwaysTailCalled join_arity <- tailCallInfo (idOccInfo bndr)-  , (bndrs, body) <- etaExpandToJoinPoint join_arity rhs-  , let str_sig   = idStrictness bndr-        str_arity = count isId bndrs  -- Strictness demands are for Ids only-        join_bndr = bndr `asJoinId`        join_arity-                         `setIdStrictness` etaExpandStrictSig str_arity str_sig-  = Just (join_bndr, mkLams bndrs body)--  | otherwise-  = Nothing--joinPointBindings_maybe :: [(InBndr, InExpr)] -> Maybe [(InBndr, InExpr)]-joinPointBindings_maybe bndrs-  = mapM (uncurry joinPointBinding_maybe) bndrs---{- Note [Strictness and join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose we have--   let f = \x.  if x>200 then e1 else e1--and we know that f is strict in x.  Then if we subsequently-discover that f is an arity-2 join point, we'll eta-expand it to--   let f = \x y.  if x>200 then e1 else e1--and now it's only strict if applied to two arguments.  So we should-adjust the strictness info.--A more common case is when--   f = \x. error ".."--and again its arity increases (#15517)--}--{- *********************************************************************-*                                                                      *-         exprIsConApp_maybe-*                                                                      *-************************************************************************--Note [exprIsConApp_maybe]-~~~~~~~~~~~~~~~~~~~~~~~~~-exprIsConApp_maybe is a very important function.  There are two principal-uses:-  * case e of { .... }-  * cls_op e, where cls_op is a class operation--In both cases you want to know if e is of form (C e1..en) where C is-a data constructor.--However e might not *look* as if---Note [exprIsConApp_maybe on literal strings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-See #9400 and #13317.--Conceptually, a string literal "abc" is just ('a':'b':'c':[]), but in Core-they are represented as unpackCString# "abc"# by MkCore.mkStringExprFS, or-unpackCStringUtf8# when the literal contains multi-byte UTF8 characters.--For optimizations we want to be able to treat it as a list, so they can be-decomposed when used in a case-statement. exprIsConApp_maybe detects those-calls to unpackCString# and returns:--Just (':', [Char], ['a', unpackCString# "bc"]).--We need to be careful about UTF8 strings here. ""# contains a ByteString, so-we must parse it back into a FastString to split off the first character.-That way we can treat unpackCString# and unpackCStringUtf8# in the same way.--We must also be careful about-   lvl = "foo"#-   ...(unpackCString# lvl)...-to ensure that we see through the let-binding for 'lvl'.  Hence the-(exprIsLiteral_maybe .. arg) in the guard before the call to-dealWithStringLiteral.--Note [Push coercions in exprIsConApp_maybe]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In #13025 I found a case where we had-    op (df @t1 @t2)     -- op is a ClassOp-where-    df = (/\a b. K e1 e2) |> g--To get this to come out we need to simplify on the fly-   ((/\a b. K e1 e2) |> g) @t1 @t2--Hence the use of pushCoArgs.--Note [exprIsConApp_maybe on data constructors with wrappers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Problem:-- some data constructors have wrappers-- these wrappers inline late (see MkId Note [Activation for data constructor wrappers])-- but we still want case-of-known-constructor to fire early.--Example:-   data T = MkT !Int-   $WMkT n = case n of n' -> MkT n'   -- Wrapper for MkT-   foo x = case $WMkT e of MkT y -> blah--Here we want the case-of-known-constructor transformation to fire, giving-   foo x = case e of x' -> let y = x' in blah--Here's how exprIsConApp_maybe achieves this:--0.  Start with scrutinee = $WMkT e--1.  Inline $WMkT on-the-fly.  That's why data-constructor wrappers are marked-    as expandable. (See CoreUtils.isExpandableApp.) Now we have-      scrutinee = (\n. case n of n' -> MkT n') e--2.  Beta-reduce the application, generating a floated 'let'.-    See Note [beta-reduction in exprIsConApp_maybe] below.  Now we have-      scrutinee = case n of n' -> MkT n'-      with floats {Let n = e}--3.  Float the "case x of x' ->" binding out.  Now we have-      scrutinee = MkT n'-      with floats {Let n = e; case n of n' ->}--And now we have a known-constructor MkT that we can return.--Notice that both (2) and (3) require exprIsConApp_maybe to gather and return-a bunch of floats, both let and case bindings.--Note [beta-reduction in exprIsConApp_maybe]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The unfolding a definition (_e.g._ a let-bound variable or a datacon wrapper) is-typically a function. For instance, take the wrapper for MkT in Note-[exprIsConApp_maybe on data constructors with wrappers]:--    $WMkT n = case n of { n' -> T n' }--If `exprIsConApp_maybe` is trying to analyse `$MkT arg`, upon unfolding of $MkT,-it will see--   (\n -> case n of { n' -> T n' }) arg--In order to go progress, `exprIsConApp_maybe` must perform a beta-reduction.--We don't want to blindly substitute `arg` in the body of the function, because-it duplicates work. We can (and, in fact, used to) substitute `arg` in the body,-but only when `arg` is a variable (or something equally work-free).--But, because of Note [exprIsConApp_maybe on data constructors with wrappers],-'exprIsConApp_maybe' now returns floats. So, instead, we can beta-reduce-_always_:--    (\x -> body) arg--Is transformed into--   let x = arg in body--Which, effectively, means emitting a float `let x = arg` and recursively-analysing the body.--For newtypes, this strategy requires that their wrappers have compulsory unfoldings.-Suppose we have-   newtype T a b where-     MkT :: a -> T b a   -- Note args swapped--This defines a worker function MkT, a wrapper function $WMkT, and an axT:-   $WMkT :: forall a b. a -> T b a-   $WMkT = /\b a. \(x:a). MkT a b x    -- A real binding--   MkT :: forall a b. a -> T a b-   MkT = /\a b. \(x:a). x |> (ax a b)  -- A compulsory unfolding--   axiom axT :: a ~R# T a b--Now we are optimising-   case $WMkT (I# 3) |> sym axT of I# y -> ...-we clearly want to simplify this. If $WMkT did not have a compulsory-unfolding, we would end up with-   let a = I#3 in case a of I# y -> ...-because in general, we do this on-the-fly beta-reduction-   (\x. e) blah  -->  let x = blah in e-and then float the the let.  (Substitution would risk duplicating 'blah'.)--But if the case-of-known-constructor doesn't actually fire (i.e.-exprIsConApp_maybe does not return Just) then nothing happens, and nothing-will happen the next time either.--See test T16254, which checks the behavior of newtypes.--}--data ConCont = CC [CoreExpr] Coercion-                  -- Substitution already applied---- | Returns @Just ([b1..bp], dc, [t1..tk], [x1..xn])@ if the argument--- expression is a *saturated* constructor application of the form @let b1 in--- .. let bp in dc t1..tk x1 .. xn@, where t1..tk are the--- *universally-quantified* type args of 'dc'. Floats can also be (and most--- likely are) single-alternative case expressions. Why does--- 'exprIsConApp_maybe' return floats? We may have to look through lets and--- cases to detect that we are in the presence of a data constructor wrapper. In--- this case, we need to return the lets and cases that we traversed. See Note--- [exprIsConApp_maybe on data constructors with wrappers]. Data constructor wrappers--- are unfolded late, but we really want to trigger case-of-known-constructor as--- early as possible. See also Note [Activation for data constructor wrappers]--- in MkId.------ We also return the incoming InScopeSet, augmented with--- the binders from any [FloatBind] that we return-exprIsConApp_maybe :: InScopeEnv -> CoreExpr-                   -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])-exprIsConApp_maybe (in_scope, id_unf) expr-  = go (Left in_scope) [] expr (CC [] (mkRepReflCo (exprType expr)))-  where-    go :: Either InScopeSet Subst-             -- Left in-scope  means "empty substitution"-             -- Right subst    means "apply this substitution to the CoreExpr"-             -- NB: in the call (go subst floats expr cont)-             --     the substitution applies to 'expr', but /not/ to 'floats' or 'cont'-       -> [FloatBind] -> CoreExpr -> ConCont-             -- Notice that the floats here are in reverse order-       -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])-    go subst floats (Tick t expr) cont-       | not (tickishIsCode t) = go subst floats expr cont--    go subst floats (Cast expr co1) (CC args co2)-       | Just (args', m_co1') <- pushCoArgs (subst_co subst co1) args-            -- See Note [Push coercions in exprIsConApp_maybe]-       = case m_co1' of-           MCo co1' -> go subst floats expr (CC args' (co1' `mkTransCo` co2))-           MRefl    -> go subst floats expr (CC args' co2)--    go subst floats (App fun arg) (CC args co)-       = go subst floats fun (CC (subst_expr subst arg : args) co)--    go subst floats (Lam bndr body) (CC (arg:args) co)-       | exprIsTrivial arg          -- Don't duplicate stuff!-       = go (extend subst bndr arg) floats body (CC args co)-       | otherwise-       = let (subst', bndr') = subst_bndr subst bndr-             float           = FloatLet (NonRec bndr' arg)-         in go subst' (float:floats) body (CC args co)--    go subst floats (Let (NonRec bndr rhs) expr) cont-       = let rhs'            = subst_expr subst rhs-             (subst', bndr') = subst_bndr subst bndr-             float           = FloatLet (NonRec bndr' rhs')-         in go subst' (float:floats) expr cont--    go subst floats (Case scrut b _ [(con, vars, expr)]) cont-       = let-          scrut'           = subst_expr subst scrut-          (subst', b')     = subst_bndr subst b-          (subst'', vars') = subst_bndrs subst' vars-          float            = FloatCase scrut' b' con vars'-         in-           go subst'' (float:floats) expr cont--    go (Right sub) floats (Var v) cont-       = go (Left (substInScope sub))-            floats-            (lookupIdSubst (text "exprIsConApp" <+> ppr expr) sub v)-            cont--    go (Left in_scope) floats (Var fun) cont@(CC args co)--        | Just con <- isDataConWorkId_maybe fun-        , count isValArg args == idArity fun-        = succeedWith in_scope floats $-          pushCoDataCon con args co--        -- Look through data constructor wrappers: they inline late (See Note-        -- [Activation for data constructor wrappers]) but we want to do-        -- case-of-known-constructor optimisation eagerly.-        | isDataConWrapId fun-        , let rhs = uf_tmpl (realIdUnfolding fun)-        = go (Left in_scope) floats rhs cont--        -- Look through dictionary functions; see Note [Unfolding DFuns]-        | DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = dfun_args } <- unfolding-        , bndrs `equalLength` args    -- See Note [DFun arity check]-        , let subst = mkOpenSubst in_scope (bndrs `zip` args)-        = succeedWith in_scope floats $-          pushCoDataCon con (map (substExpr (text "exprIsConApp1") subst) dfun_args) co--        -- Look through unfoldings, but only arity-zero one;-        -- if arity > 0 we are effectively inlining a function call,-        -- and that is the business of callSiteInline.-        -- In practice, without this test, most of the "hits" were-        -- CPR'd workers getting inlined back into their wrappers,-        | idArity fun == 0-        , Just rhs <- expandUnfolding_maybe unfolding-        , let in_scope' = extendInScopeSetSet in_scope (exprFreeVars rhs)-        = go (Left in_scope') floats rhs cont--        -- See Note [exprIsConApp_maybe on literal strings]-        | (fun `hasKey` unpackCStringIdKey) ||-          (fun `hasKey` unpackCStringUtf8IdKey)-        , [arg]              <- args-        , Just (LitString str) <- exprIsLiteral_maybe (in_scope, id_unf) arg-        = succeedWith in_scope floats $-          dealWithStringLiteral fun str co-        where-          unfolding = id_unf fun--    go _ _ _ _ = Nothing--    succeedWith :: InScopeSet -> [FloatBind]-                -> Maybe (DataCon, [Type], [CoreExpr])-                -> Maybe (InScopeSet, [FloatBind], DataCon, [Type], [CoreExpr])-    succeedWith in_scope rev_floats x-      = do { (con, tys, args) <- x-           ; let floats = reverse rev_floats-           ; return (in_scope, floats, con, tys, args) }--    -----------------------------    -- Operations on the (Either InScopeSet CoreSubst)-    -- The Left case is wildly dominant-    subst_co (Left {}) co = co-    subst_co (Right s) co = CoreSubst.substCo s co--    subst_expr (Left {}) e = e-    subst_expr (Right s) e = substExpr (text "exprIsConApp2") s e--    subst_bndr msubst bndr-      = (Right subst', bndr')-      where-        (subst', bndr') = substBndr subst bndr-        subst = case msubst of-                  Left in_scope -> mkEmptySubst in_scope-                  Right subst   -> subst--    subst_bndrs subst bs = mapAccumL subst_bndr subst bs--    extend (Left in_scope) v e = Right (extendSubst (mkEmptySubst in_scope) v e)-    extend (Right s)       v e = Right (extendSubst s v e)----- See Note [exprIsConApp_maybe on literal strings]-dealWithStringLiteral :: Var -> BS.ByteString -> Coercion-                      -> Maybe (DataCon, [Type], [CoreExpr])---- This is not possible with user-supplied empty literals, MkCore.mkStringExprFS--- turns those into [] automatically, but just in case something else in GHC--- generates a string literal directly.-dealWithStringLiteral _   str co-  | BS.null str-  = pushCoDataCon nilDataCon [Type charTy] co--dealWithStringLiteral fun str co-  = let strFS = mkFastStringByteString str--        char = mkConApp charDataCon [mkCharLit (headFS strFS)]-        charTail = bytesFS (tailFS strFS)--        -- In singleton strings, just add [] instead of unpackCstring# ""#.-        rest = if BS.null charTail-                 then mkConApp nilDataCon [Type charTy]-                 else App (Var fun)-                          (Lit (LitString charTail))--    in pushCoDataCon consDataCon [Type charTy, char, rest] co--{--Note [Unfolding DFuns]-~~~~~~~~~~~~~~~~~~~~~~-DFuns look like--  df :: forall a b. (Eq a, Eq b) -> Eq (a,b)-  df a b d_a d_b = MkEqD (a,b) ($c1 a b d_a d_b)-                               ($c2 a b d_a d_b)--So to split it up we just need to apply the ops $c1, $c2 etc-to the very same args as the dfun.  It takes a little more work-to compute the type arguments to the dictionary constructor.--Note [DFun arity check]-~~~~~~~~~~~~~~~~~~~~~~~-Here we check that the total number of supplied arguments (including-type args) matches what the dfun is expecting.  This may be *less*-than the ordinary arity of the dfun: see Note [DFun unfoldings] in CoreSyn--}--exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal--- Same deal as exprIsConApp_maybe, but much simpler--- Nevertheless we do need to look through unfoldings for--- Integer and string literals, which are vigorously hoisted to top level--- and not subsequently inlined-exprIsLiteral_maybe env@(_, id_unf) e-  = case e of-      Lit l     -> Just l-      Tick _ e' -> exprIsLiteral_maybe env e' -- dubious?-      Var v     | Just rhs <- expandUnfolding_maybe (id_unf v)-                -> exprIsLiteral_maybe env rhs-      _         -> Nothing--{--Note [exprIsLambda_maybe]-~~~~~~~~~~~~~~~~~~~~~~~~~~-exprIsLambda_maybe will, given an expression `e`, try to turn it into the form-`Lam v e'` (returned as `Just (v,e')`). Besides using lambdas, it looks through-casts (using the Push rule), and it unfolds function calls if the unfolding-has a greater arity than arguments are present.--Currently, it is used in Rules.match, and is required to make-"map coerce = coerce" match.--}--exprIsLambda_maybe :: InScopeEnv -> CoreExpr-                      -> Maybe (Var, CoreExpr,[Tickish Id])-    -- See Note [exprIsLambda_maybe]---- The simple case: It is a lambda already-exprIsLambda_maybe _ (Lam x e)-    = Just (x, e, [])---- Still straightforward: Ticks that we can float out of the way-exprIsLambda_maybe (in_scope_set, id_unf) (Tick t e)-    | tickishFloatable t-    , Just (x, e, ts) <- exprIsLambda_maybe (in_scope_set, id_unf) e-    = Just (x, e, t:ts)---- Also possible: A casted lambda. Push the coercion inside-exprIsLambda_maybe (in_scope_set, id_unf) (Cast casted_e co)-    | Just (x, e,ts) <- exprIsLambda_maybe (in_scope_set, id_unf) casted_e-    -- Only do value lambdas.-    -- this implies that x is not in scope in gamma (makes this code simpler)-    , not (isTyVar x) && not (isCoVar x)-    , ASSERT( not $ x `elemVarSet` tyCoVarsOfCo co) True-    , Just (x',e') <- pushCoercionIntoLambda in_scope_set x e co-    , let res = Just (x',e',ts)-    = --pprTrace "exprIsLambda_maybe:Cast" (vcat [ppr casted_e,ppr co,ppr res)])-      res---- Another attempt: See if we find a partial unfolding-exprIsLambda_maybe (in_scope_set, id_unf) e-    | (Var f, as, ts) <- collectArgsTicks tickishFloatable e-    , idArity f > count isValArg as-    -- Make sure there is hope to get a lambda-    , Just rhs <- expandUnfolding_maybe (id_unf f)-    -- Optimize, for beta-reduction-    , let e' = simpleOptExprWith unsafeGlobalDynFlags (mkEmptySubst in_scope_set) (rhs `mkApps` as)-    -- Recurse, because of possible casts-    , Just (x', e'', ts') <- exprIsLambda_maybe (in_scope_set, id_unf) e'-    , let res = Just (x', e'', ts++ts')-    = -- pprTrace "exprIsLambda_maybe:Unfold" (vcat [ppr e, ppr (x',e'')])-      res--exprIsLambda_maybe _ _e-    = -- pprTrace "exprIsLambda_maybe:Fail" (vcat [ppr _e])-      Nothing---{- *********************************************************************-*                                                                      *-              The "push rules"-*                                                                      *-************************************************************************--Here we implement the "push rules" from FC papers:--* The push-argument rules, where we can move a coercion past an argument.-  We have-      (fun |> co) arg-  and we want to transform it to-    (fun arg') |> co'-  for some suitable co' and transformed arg'.--* The PushK rule for data constructors.  We have-       (K e1 .. en) |> co-  and we want to transform to-       (K e1' .. en')-  by pushing the coercion into the arguments--}--pushCoArgs :: CoercionR -> [CoreArg] -> Maybe ([CoreArg], MCoercion)-pushCoArgs co []         = return ([], MCo co)-pushCoArgs co (arg:args) = do { (arg',  m_co1) <- pushCoArg  co  arg-                              ; case m_co1 of-                                  MCo co1 -> do { (args', m_co2) <- pushCoArgs co1 args-                                                 ; return (arg':args', m_co2) }-                                  MRefl  -> return (arg':args, MRefl) }--pushCoArg :: CoercionR -> CoreArg -> Maybe (CoreArg, MCoercion)--- We have (fun |> co) arg, and we want to transform it to---         (fun arg) |> co--- This may fail, e.g. if (fun :: N) where N is a newtype--- C.f. simplCast in Simplify.hs--- 'co' is always Representational--- If the returned coercion is Nothing, then it would have been reflexive-pushCoArg co (Type ty) = do { (ty', m_co') <- pushCoTyArg co ty-                            ; return (Type ty', m_co') }-pushCoArg co val_arg   = do { (arg_co, m_co') <- pushCoValArg co-                            ; return (val_arg `mkCast` arg_co, m_co') }--pushCoTyArg :: CoercionR -> Type -> Maybe (Type, MCoercionR)--- We have (fun |> co) @ty--- Push the coercion through to return---         (fun @ty') |> co'--- 'co' is always Representational--- If the returned coercion is Nothing, then it would have been reflexive;--- it's faster not to compute it, though.-pushCoTyArg co ty-  -- The following is inefficient - don't do `eqType` here, the coercion-  -- optimizer will take care of it. See #14737.-  -- -- | tyL `eqType` tyR-  -- -- = Just (ty, Nothing)--  | isReflCo co-  = Just (ty, MRefl)--  | isForAllTy_ty tyL-  = ASSERT2( isForAllTy_ty tyR, ppr co $$ ppr ty )-    Just (ty `mkCastTy` co1, MCo co2)--  | otherwise-  = Nothing-  where-    tyL = coercionLKind co-    tyR = coercionRKind co-       -- co :: tyL ~ tyR-       -- tyL = forall (a1 :: k1). ty1-       -- tyR = forall (a2 :: k2). ty2--    co1 = mkSymCo (mkNthCo Nominal 0 co)-       -- co1 :: k2 ~N k1-       -- Note that NthCo can extract a Nominal equality between the-       -- kinds of the types related by a coercion between forall-types.-       -- See the NthCo case in CoreLint.--    co2 = mkInstCo co (mkGReflLeftCo Nominal ty co1)-        -- co2 :: ty1[ (ty|>co1)/a1 ] ~ ty2[ ty/a2 ]-        -- Arg of mkInstCo is always nominal, hence mkNomReflCo--pushCoValArg :: CoercionR -> Maybe (Coercion, MCoercion)--- We have (fun |> co) arg--- Push the coercion through to return---         (fun (arg |> co_arg)) |> co_res--- 'co' is always Representational--- If the second returned Coercion is actually Nothing, then no cast is necessary;--- the returned coercion would have been reflexive.-pushCoValArg co-  -- The following is inefficient - don't do `eqType` here, the coercion-  -- optimizer will take care of it. See #14737.-  -- -- | tyL `eqType` tyR-  -- -- = Just (mkRepReflCo arg, Nothing)--  | isReflCo co-  = Just (mkRepReflCo arg, MRefl)--  | isFunTy tyL-  , (co1, co2) <- decomposeFunCo Representational co-              -- If   co  :: (tyL1 -> tyL2) ~ (tyR1 -> tyR2)-              -- then co1 :: tyL1 ~ tyR1-              --      co2 :: tyL2 ~ tyR2-  = ASSERT2( isFunTy tyR, ppr co $$ ppr arg )-    Just (mkSymCo co1, MCo co2)--  | otherwise-  = Nothing-  where-    arg = funArgTy tyR-    Pair tyL tyR = coercionKind co--pushCoercionIntoLambda-    :: InScopeSet -> Var -> CoreExpr -> CoercionR -> Maybe (Var, CoreExpr)--- This implements the Push rule from the paper on coercions---    (\x. e) |> co--- ===>---    (\x'. e |> co')-pushCoercionIntoLambda in_scope x e co-    | ASSERT(not (isTyVar x) && not (isCoVar x)) True-    , Pair s1s2 t1t2 <- coercionKind co-    , Just (_s1,_s2) <- splitFunTy_maybe s1s2-    , Just (t1,_t2) <- splitFunTy_maybe t1t2-    = let (co1, co2) = decomposeFunCo Representational co-          -- Should we optimize the coercions here?-          -- Otherwise they might not match too well-          x' = x `setIdType` t1-          in_scope' = in_scope `extendInScopeSet` x'-          subst = extendIdSubst (mkEmptySubst in_scope')-                                x-                                (mkCast (Var x') co1)-      in Just (x', substExpr (text "pushCoercionIntoLambda") subst e `mkCast` co2)-    | otherwise-    = pprTrace "exprIsLambda_maybe: Unexpected lambda in case" (ppr (Lam x e))-      Nothing--pushCoDataCon :: DataCon -> [CoreExpr] -> Coercion-              -> Maybe (DataCon-                       , [Type]      -- Universal type args-                       , [CoreExpr]) -- All other args incl existentials--- Implement the KPush reduction rule as described in "Down with kinds"--- The transformation applies iff we have---      (C e1 ... en) `cast` co--- where co :: (T t1 .. tn) ~ to_ty--- The left-hand one must be a T, because exprIsConApp returned True--- but the right-hand one might not be.  (Though it usually will.)-pushCoDataCon dc dc_args co-  | isReflCo co || from_ty `eqType` to_ty  -- try cheap test first-  , let (univ_ty_args, rest_args) = splitAtList (dataConUnivTyVars dc) dc_args-  = Just (dc, map exprToType univ_ty_args, rest_args)--  | Just (to_tc, to_tc_arg_tys) <- splitTyConApp_maybe to_ty-  , to_tc == dataConTyCon dc-        -- These two tests can fail; we might see-        --      (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's nothing wrong with it--  = let-        tc_arity       = tyConArity to_tc-        dc_univ_tyvars = dataConUnivTyVars dc-        dc_ex_tcvars   = dataConExTyCoVars dc-        arg_tys        = dataConRepArgTys dc--        non_univ_args  = dropList dc_univ_tyvars dc_args-        (ex_args, val_args) = splitAtList dc_ex_tcvars non_univ_args--        -- Make the "Psi" from the paper-        omegas = decomposeCo tc_arity co (tyConRolesRepresentational to_tc)-        (psi_subst, to_ex_arg_tys)-          = liftCoSubstWithEx Representational-                              dc_univ_tyvars-                              omegas-                              dc_ex_tcvars-                              (map exprToType ex_args)--          -- Cast the value arguments (which include dictionaries)-        new_val_args = zipWith cast_arg arg_tys val_args-        cast_arg arg_ty arg = mkCast arg (psi_subst arg_ty)--        to_ex_args = map Type to_ex_arg_tys--        dump_doc = vcat [ppr dc,      ppr dc_univ_tyvars, ppr dc_ex_tcvars,-                         ppr arg_tys, ppr dc_args,-                         ppr ex_args, ppr val_args, ppr co, ppr from_ty, ppr to_ty, ppr to_tc ]-    in-    ASSERT2( eqType from_ty (mkTyConApp to_tc (map exprToType $ takeList dc_univ_tyvars dc_args)), dump_doc )-    ASSERT2( equalLength val_args arg_tys, dump_doc )-    Just (dc, to_tc_arg_tys, to_ex_args ++ new_val_args)--  | otherwise-  = Nothing--  where-    Pair from_ty to_ty = coercionKind co--collectBindersPushingCo :: CoreExpr -> ([Var], CoreExpr)--- Collect lambda binders, pushing coercions inside if possible--- E.g.   (\x.e) |> g         g :: <Int> -> blah---        = (\x. e |> Nth 1 g)------ That is,------ collectBindersPushingCo ((\x.e) |> g) === ([x], e |> Nth 1 g)-collectBindersPushingCo e-  = go [] e-  where-    -- Peel off lambdas until we hit a cast.-    go :: [Var] -> CoreExpr -> ([Var], CoreExpr)-    -- The accumulator is in reverse order-    go bs (Lam b e)   = go (b:bs) e-    go bs (Cast e co) = go_c bs e co-    go bs e           = (reverse bs, e)--    -- We are in a cast; peel off casts until we hit a lambda.-    go_c :: [Var] -> CoreExpr -> CoercionR -> ([Var], CoreExpr)-    -- (go_c bs e c) is same as (go bs e (e |> c))-    go_c bs (Cast e co1) co2 = go_c bs e (co1 `mkTransCo` co2)-    go_c bs (Lam b e)    co  = go_lam bs b e co-    go_c bs e            co  = (reverse bs, mkCast e co)--    -- We are in a lambda under a cast; peel off lambdas and build a-    -- new coercion for the body.-    go_lam :: [Var] -> Var -> CoreExpr -> CoercionR -> ([Var], CoreExpr)-    -- (go_lam bs b e c) is same as (go_c bs (\b.e) c)-    go_lam bs b e co-      | isTyVar b-      , let Pair tyL tyR = coercionKind co-      , ASSERT( isForAllTy_ty tyL )-        isForAllTy_ty tyR-      , isReflCo (mkNthCo Nominal 0 co)  -- See Note [collectBindersPushingCo]-      = go_c (b:bs) e (mkInstCo co (mkNomReflCo (mkTyVarTy b)))--      | isCoVar b-      , let Pair tyL tyR = coercionKind co-      , ASSERT( isForAllTy_co tyL )-        isForAllTy_co tyR-      , isReflCo (mkNthCo Nominal 0 co)  -- See Note [collectBindersPushingCo]-      , let cov = mkCoVarCo b-      = go_c (b:bs) e (mkInstCo co (mkNomReflCo (mkCoercionTy cov)))--      | isId b-      , let Pair tyL tyR = coercionKind co-      , ASSERT( isFunTy tyL) isFunTy tyR-      , (co_arg, co_res) <- decomposeFunCo Representational co-      , isReflCo co_arg  -- See Note [collectBindersPushingCo]-      = go_c (b:bs) e co_res--      | otherwise = (reverse bs, mkCast (Lam b e) co)--{---Note [collectBindersPushingCo]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We just look for coercions of form-   <type> -> blah-(and similarly for foralls) to keep this function simple.  We could do-more elaborate stuff, but it'd involve substitution etc.---}

− compiler/coreSyn/CoreSeq.hs

@@ -1,113 +0,0 @@--- |--- Various utilities for forcing Core structures------ It can often be useful to force various parts of the AST. This module--- provides a number of @seq@-like functions to accomplish this.--module CoreSeq (-        -- * Utilities for forcing Core structures-        seqExpr, seqExprs, seqUnfolding, seqRules,-        megaSeqIdInfo, seqRuleInfo, seqBinds,-    ) where--import GhcPrelude--import CoreSyn-import IdInfo-import Demand( seqDemand, seqStrictSig )-import BasicTypes( seqOccInfo )-import VarSet( seqDVarSet )-import Var( varType, tyVarKind )-import Type( seqType, isTyVar )-import Coercion( seqCo )-import Id( Id, idInfo )---- | Evaluate all the fields of the 'IdInfo' that are generally demanded by the--- compiler-megaSeqIdInfo :: IdInfo -> ()-megaSeqIdInfo info-  = seqRuleInfo (ruleInfo info)                 `seq`---- Omitting this improves runtimes a little, presumably because--- some unfoldings are not calculated at all---    seqUnfolding (unfoldingInfo info)         `seq`--    seqDemand (demandInfo info)                 `seq`-    seqStrictSig (strictnessInfo info)          `seq`-    seqCaf (cafInfo info)                       `seq`-    seqOneShot (oneShotInfo info)               `seq`-    seqOccInfo (occInfo info)--seqOneShot :: OneShotInfo -> ()-seqOneShot l = l `seq` ()--seqRuleInfo :: RuleInfo -> ()-seqRuleInfo (RuleInfo rules fvs) = seqRules rules `seq` seqDVarSet fvs--seqCaf :: CafInfo -> ()-seqCaf c = c `seq` ()--seqRules :: [CoreRule] -> ()-seqRules [] = ()-seqRules (Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs } : rules)-  = seqBndrs bndrs `seq` seqExprs (rhs:args) `seq` seqRules rules-seqRules (BuiltinRule {} : rules) = seqRules rules--seqExpr :: CoreExpr -> ()-seqExpr (Var v)         = v `seq` ()-seqExpr (Lit lit)       = lit `seq` ()-seqExpr (App f a)       = seqExpr f `seq` seqExpr a-seqExpr (Lam b e)       = seqBndr b `seq` seqExpr e-seqExpr (Let b e)       = seqBind b `seq` seqExpr e-seqExpr (Case e b t as) = seqExpr e `seq` seqBndr b `seq` seqType t `seq` seqAlts as-seqExpr (Cast e co)     = seqExpr e `seq` seqCo co-seqExpr (Tick n e)      = seqTickish n `seq` seqExpr e-seqExpr (Type t)        = seqType t-seqExpr (Coercion co)   = seqCo co--seqExprs :: [CoreExpr] -> ()-seqExprs [] = ()-seqExprs (e:es) = seqExpr e `seq` seqExprs es--seqTickish :: Tickish Id -> ()-seqTickish ProfNote{ profNoteCC = cc } = cc `seq` ()-seqTickish HpcTick{} = ()-seqTickish Breakpoint{ breakpointFVs = ids } = seqBndrs ids-seqTickish SourceNote{} = ()--seqBndr :: CoreBndr -> ()-seqBndr b | isTyVar b = seqType (tyVarKind b)-          | otherwise = seqType (varType b)             `seq`-                        megaSeqIdInfo (idInfo b)--seqBndrs :: [CoreBndr] -> ()-seqBndrs [] = ()-seqBndrs (b:bs) = seqBndr b `seq` seqBndrs bs--seqBinds :: [Bind CoreBndr] -> ()-seqBinds bs = foldr (seq . seqBind) () bs--seqBind :: Bind CoreBndr -> ()-seqBind (NonRec b e) = seqBndr b `seq` seqExpr e-seqBind (Rec prs)    = seqPairs prs--seqPairs :: [(CoreBndr, CoreExpr)] -> ()-seqPairs [] = ()-seqPairs ((b,e):prs) = seqBndr b `seq` seqExpr e `seq` seqPairs prs--seqAlts :: [CoreAlt] -> ()-seqAlts [] = ()-seqAlts ((c,bs,e):alts) = c `seq` seqBndrs bs `seq` seqExpr e `seq` seqAlts alts--seqUnfolding :: Unfolding -> ()-seqUnfolding (CoreUnfolding { uf_tmpl = e, uf_is_top = top,-                uf_is_value = b1, uf_is_work_free = b2,-                uf_expandable = b3, uf_is_conlike = b4,-                uf_guidance = g})-  = seqExpr e `seq` top `seq` b1 `seq` b2 `seq` b3 `seq` b4 `seq` seqGuidance g--seqUnfolding _ = ()--seqGuidance :: UnfoldingGuidance -> ()-seqGuidance (UnfIfGoodArgs ns n b) = n `seq` sum ns `seq` b `seq` ()-seqGuidance _                      = ()

− compiler/coreSyn/CoreStats.hs

@@ -1,137 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-2015--}---- | Functions to computing the statistics reflective of the "size"--- of a Core expression-module CoreStats (-        -- * Expression and bindings size-        coreBindsSize, exprSize,-        CoreStats(..), coreBindsStats, exprStats,-    ) where--import GhcPrelude--import BasicTypes-import CoreSyn-import Outputable-import Coercion-import Var-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---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,-                  text "types:"     <+> intWithCommas i2 <> comma,-                  text "coercions:" <+> intWithCommas i3 <> comma,-                  text "joins:"     <+> intWithCommas i5 <> char '/' <>-                                        intWithCommas (i4 + i5) ])--plusCS :: CoreStats -> CoreStats -> CoreStats-plusCS (CS { cs_tm = p1, cs_ty = q1, cs_co = r1, cs_vb = v1, cs_jb = j1 })-       (CS { cs_tm = p2, cs_ty = q2, cs_co = r2, cs_vb = v2, cs_jb = j2 })-  = CS { cs_tm = p1+p2, cs_ty = q1+q2, cs_co = r1+r2, cs_vb = v1+v2-       , cs_jb = j1+j2 }--zeroCS, oneTM :: CoreStats-zeroCS = CS { cs_tm = 0, cs_ty = 0, cs_co = 0, cs_vb = 0, cs_jb = 0 }-oneTM  = zeroCS { cs_tm = 1 }--sumCS :: (a -> CoreStats) -> [a] -> CoreStats-sumCS f = foldl' (\s a -> plusCS s (f a)) zeroCS--coreBindsStats :: [CoreBind] -> CoreStats-coreBindsStats = sumCS (bindStats TopLevel)--bindStats :: TopLevelFlag -> CoreBind -> CoreStats-bindStats top_lvl (NonRec v r) = bindingStats top_lvl v r-bindStats top_lvl (Rec prs)    = sumCS (\(v,r) -> bindingStats top_lvl v r) prs--bindingStats :: TopLevelFlag -> Var -> CoreExpr -> CoreStats-bindingStats top_lvl v r = letBndrStats top_lvl v `plusCS` exprStats r--bndrStats :: Var -> CoreStats-bndrStats v = oneTM `plusCS` tyStats (varType v)--letBndrStats :: TopLevelFlag -> Var -> CoreStats-letBndrStats top_lvl v-  | isTyVar v || isTopLevel top_lvl = bndrStats v-  | isJoinId v = oneTM { cs_jb = 1 } `plusCS` ty_stats-  | otherwise  = oneTM { cs_vb = 1 } `plusCS` ty_stats-  where-    ty_stats = tyStats (varType v)--exprStats :: CoreExpr -> CoreStats-exprStats (Var {})        = oneTM-exprStats (Lit {})        = oneTM-exprStats (Type t)        = tyStats t-exprStats (Coercion c)    = coStats c-exprStats (App f a)       = exprStats f `plusCS` exprStats a-exprStats (Lam b e)       = bndrStats b `plusCS` exprStats e-exprStats (Let b e)       = bindStats NotTopLevel b `plusCS` exprStats e-exprStats (Case e b _ as) = exprStats e `plusCS` bndrStats b-                                        `plusCS` sumCS altStats as-exprStats (Cast e co)     = coStats co `plusCS` exprStats e-exprStats (Tick _ e)      = exprStats e--altStats :: CoreAlt -> CoreStats-altStats (_, bs, r) = altBndrStats bs `plusCS` exprStats r--altBndrStats :: [Var] -> CoreStats--- Charge one for the alternative, not for each binder-altBndrStats vs = oneTM `plusCS` sumCS (tyStats . varType) vs--tyStats :: Type -> CoreStats-tyStats ty = zeroCS { cs_ty = typeSize ty }--coStats :: Coercion -> CoreStats-coStats co = zeroCS { cs_co = coercionSize co }--coreBindsSize :: [CoreBind] -> Int--- We use coreBindStats for user printout--- but this one is a quick and dirty basis for--- the simplifier's tick limit-coreBindsSize bs = sum (map bindSize bs)--exprSize :: CoreExpr -> Int--- ^ A measure of the size of the expressions, strictly greater than 0--- Counts *leaves*, not internal nodes. Types and coercions are not counted.-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 _ 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 _)        = 1-exprSize (Coercion _)    = 1--tickSize :: Tickish Id -> Int-tickSize (ProfNote _ _ _) = 1-tickSize _ = 1--bndrSize :: Var -> Int-bndrSize _ = 1--bndrsSize :: [Var] -> Int-bndrsSize = sum . map bndrSize--bindSize :: CoreBind -> Int-bindSize (NonRec b e) = bndrSize b + exprSize e-bindSize (Rec prs)    = sum (map pairSize prs)--pairSize :: (Var, CoreExpr) -> Int-pairSize (b,e) = bndrSize b + exprSize e--altSize :: CoreAlt -> Int-altSize (_,bs,e) = bndrsSize bs + exprSize e

− compiler/coreSyn/CoreSubst.hs

@@ -1,758 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998---Utility functions on @Core@ syntax--}--{-# LANGUAGE CPP #-}-{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}-module CoreSubst (-        -- * Main data types-        Subst(..), -- Implementation exported for supercompiler's Renaming.hs only-        TvSubstEnv, IdSubstEnv, InScopeSet,--        -- ** Substituting into expressions and related types-        deShadowBinds, substSpec, substRulesForImportedIds,-        substTy, substCo, substExpr, substExprSC, substBind, substBindSC,-        substUnfolding, substUnfoldingSC,-        lookupIdSubst, lookupTCvSubst, substIdOcc,-        substTickish, substDVarSet, substIdInfo,--        -- ** Operations on substitutions-        emptySubst, mkEmptySubst, mkSubst, mkOpenSubst, substInScope, isEmptySubst,-        extendIdSubst, extendIdSubstList, extendTCvSubst, extendTvSubstList,-        extendSubst, extendSubstList, extendSubstWithVar, zapSubstEnv,-        addInScopeSet, extendInScope, extendInScopeList, extendInScopeIds,-        isInScope, setInScope, getTCvSubst, extendTvSubst, extendCvSubst,-        delBndr, delBndrs,--        -- ** Substituting and cloning binders-        substBndr, substBndrs, substRecBndrs, substTyVarBndr, substCoVarBndr,-        cloneBndr, cloneBndrs, cloneIdBndr, cloneIdBndrs, cloneRecIdBndrs,--    ) where--#include "HsVersions.h"---import GhcPrelude--import CoreSyn-import CoreFVs-import CoreSeq-import CoreUtils-import qualified Type-import qualified Coercion--        -- We are defining local versions-import Type     hiding ( substTy, extendTvSubst, extendCvSubst, extendTvSubstList-                       , isInScope, substTyVarBndr, cloneTyVarBndr )-import Coercion hiding ( substCo, substCoVarBndr )--import PrelNames-import VarSet-import VarEnv-import Id-import Name     ( Name )-import Var-import IdInfo-import UniqSupply-import Maybes-import Util-import Outputable-import Data.List----{--************************************************************************-*                                                                      *-\subsection{Substitutions}-*                                                                      *-************************************************************************--}---- | A substitution environment, containing 'Id', 'TyVar', and 'CoVar'--- substitutions.------ Some invariants apply to how you use the substitution:------ 1. Note [The substitution invariant] in TyCoSubst------ 2. Note [Substitutions apply only once] in TyCoSubst-data Subst-  = Subst InScopeSet  -- Variables in in scope (both Ids and TyVars) /after/-                      -- applying the substitution-          IdSubstEnv  -- Substitution from NcIds to CoreExprs-          TvSubstEnv  -- Substitution from TyVars to Types-          CvSubstEnv  -- Substitution from CoVars to Coercions--        -- INVARIANT 1: See TyCoSubst Note [The substitution invariant]-        -- This is what lets us deal with name capture properly-        -- It's a hard invariant to check...-        ---        -- INVARIANT 2: The substitution is apply-once; see Note [Apply once] with-        --              Types.TvSubstEnv-        ---        -- INVARIANT 3: See Note [Extending the Subst]--{--Note [Extending the Subst]-~~~~~~~~~~~~~~~~~~~~~~~~~~-For a core Subst, which binds Ids as well, we make a different choice for Ids-than we do for TyVars.--For TyVars, see Note [Extending the TCvSubst] in TyCoSubst.--For Ids, we have a different invariant-        The IdSubstEnv is extended *only* when the Unique on an Id changes-        Otherwise, we just extend the InScopeSet--In consequence:--* If all subst envs are empty, substExpr would be a-  no-op, so substExprSC ("short cut") does nothing.--  However, substExpr still goes ahead and substitutes.  Reason: we may-  want to replace existing Ids with new ones from the in-scope set, to-  avoid space leaks.--* In substIdBndr, we extend the IdSubstEnv only when the unique changes--* If the CvSubstEnv, TvSubstEnv and IdSubstEnv are all empty,-  substExpr does nothing (Note that the above rule for substIdBndr-  maintains this property.  If the incoming envts are both empty, then-  substituting the type and IdInfo can't change anything.)--* In lookupIdSubst, we *must* look up the Id in the in-scope set, because-  it may contain non-trivial changes.  Example:-        (/\a. \x:a. ...x...) Int-  We extend the TvSubstEnv with [a |-> Int]; but x's unique does not change-  so we only extend the in-scope set.  Then we must look up in the in-scope-  set when we find the occurrence of x.--* The requirement to look up the Id in the in-scope set means that we-  must NOT take no-op short cut when the IdSubst is empty.-  We must still look up every Id in the in-scope set.--* (However, we don't need to do so for expressions found in the IdSubst-  itself, whose range is assumed to be correct wrt the in-scope set.)--Why do we make a different choice for the IdSubstEnv than the-TvSubstEnv and CvSubstEnv?--* For Ids, we change the IdInfo all the time (e.g. deleting the-  unfolding), and adding it back later, so using the TyVar convention-  would entail extending the substitution almost all the time--* The simplifier wants to look up in the in-scope set anyway, in case it-  can see a better unfolding from an enclosing case expression--* For TyVars, only coercion variables can possibly change, and they are-  easy to spot--}---- | An environment for substituting for 'Id's-type IdSubstEnv = IdEnv CoreExpr   -- Domain is NcIds, i.e. not coercions-------------------------------isEmptySubst :: Subst -> Bool-isEmptySubst (Subst _ id_env tv_env cv_env)-  = isEmptyVarEnv id_env && isEmptyVarEnv tv_env && isEmptyVarEnv cv_env--emptySubst :: Subst-emptySubst = Subst emptyInScopeSet emptyVarEnv emptyVarEnv emptyVarEnv--mkEmptySubst :: InScopeSet -> Subst-mkEmptySubst in_scope = Subst in_scope emptyVarEnv emptyVarEnv emptyVarEnv--mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst-mkSubst in_scope tvs cvs ids = Subst in_scope ids tvs cvs---- | Find the in-scope set: see TyCoSubst Note [The substitution invariant]-substInScope :: Subst -> InScopeSet-substInScope (Subst in_scope _ _ _) = in_scope---- | Remove all substitutions for 'Id's and 'Var's that might have been built up--- while preserving the in-scope set-zapSubstEnv :: Subst -> Subst-zapSubstEnv (Subst in_scope _ _ _) = Subst in_scope emptyVarEnv emptyVarEnv emptyVarEnv---- | Add a substitution for an 'Id' to the 'Subst': you must ensure that the in-scope set is--- such that TyCoSubst Note [The substitution invariant]--- holds after extending the substitution like this-extendIdSubst :: Subst -> Id -> CoreExpr -> Subst--- ToDo: add an ASSERT that fvs(subst-result) is already in the in-scope set-extendIdSubst (Subst in_scope ids tvs cvs) v r-  = ASSERT2( isNonCoVarId v, ppr v $$ ppr r )-    Subst in_scope (extendVarEnv ids v r) tvs cvs---- | Adds multiple 'Id' substitutions to the 'Subst': see also 'extendIdSubst'-extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst-extendIdSubstList (Subst in_scope ids tvs cvs) prs-  = ASSERT( all (isNonCoVarId . fst) prs )-    Subst in_scope (extendVarEnvList ids prs) tvs cvs---- | Add a substitution for a 'TyVar' to the 'Subst'--- The 'TyVar' *must* be a real TyVar, and not a CoVar--- You must ensure that the in-scope set is such that--- TyCoSubst Note [The substitution invariant] holds--- after extending the substitution like this.-extendTvSubst :: Subst -> TyVar -> Type -> Subst-extendTvSubst (Subst in_scope ids tvs cvs) tv ty-  = ASSERT( isTyVar tv )-    Subst in_scope ids (extendVarEnv tvs tv ty) cvs---- | Adds multiple 'TyVar' substitutions to the 'Subst': see also 'extendTvSubst'-extendTvSubstList :: Subst -> [(TyVar,Type)] -> Subst-extendTvSubstList subst vrs-  = foldl' extend subst vrs-  where-    extend subst (v, r) = extendTvSubst subst v r---- | Add a substitution from a 'CoVar' to a 'Coercion' to the 'Subst':--- you must ensure that the in-scope set satisfies--- TyCoSubst Note [The substitution invariant]--- after extending the substitution like this-extendCvSubst :: Subst -> CoVar -> Coercion -> Subst-extendCvSubst (Subst in_scope ids tvs cvs) v r-  = ASSERT( isCoVar v )-    Subst in_scope ids tvs (extendVarEnv cvs v r)---- | Add a substitution appropriate to the thing being substituted---   (whether an expression, type, or coercion). See also---   'extendIdSubst', 'extendTvSubst', 'extendCvSubst'-extendSubst :: Subst -> Var -> CoreArg -> Subst-extendSubst subst var arg-  = case arg of-      Type ty     -> ASSERT( isTyVar var ) extendTvSubst subst var ty-      Coercion co -> ASSERT( isCoVar var ) extendCvSubst subst var co-      _           -> ASSERT( isId    var ) extendIdSubst subst var arg--extendSubstWithVar :: Subst -> Var -> Var -> Subst-extendSubstWithVar subst v1 v2-  | isTyVar v1 = ASSERT( isTyVar v2 ) extendTvSubst subst v1 (mkTyVarTy v2)-  | isCoVar v1 = ASSERT( isCoVar v2 ) extendCvSubst subst v1 (mkCoVarCo v2)-  | otherwise  = ASSERT( isId    v2 ) extendIdSubst subst v1 (Var v2)---- | Add a substitution as appropriate to each of the terms being---   substituted (whether expressions, types, or coercions). See also---   'extendSubst'.-extendSubstList :: Subst -> [(Var,CoreArg)] -> Subst-extendSubstList subst []              = subst-extendSubstList subst ((var,rhs):prs) = extendSubstList (extendSubst subst var rhs) prs---- | Find the substitution for an 'Id' in the 'Subst'-lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr-lookupIdSubst doc (Subst in_scope ids _ _) v-  | not (isLocalId v) = Var v-  | Just e  <- lookupVarEnv ids       v = e-  | Just v' <- lookupInScope in_scope v = Var v'-        -- Vital! See Note [Extending the Subst]-  | otherwise = WARN( True, text "CoreSubst.lookupIdSubst" <+> doc <+> ppr v-                            $$ ppr in_scope)-                Var v---- | Find the substitution for a 'TyVar' in the 'Subst'-lookupTCvSubst :: Subst -> TyVar -> Type-lookupTCvSubst (Subst _ _ tvs cvs) v-  | isTyVar v-  = lookupVarEnv tvs v `orElse` Type.mkTyVarTy v-  | otherwise-  = mkCoercionTy $ lookupVarEnv cvs v `orElse` mkCoVarCo v--delBndr :: Subst -> Var -> Subst-delBndr (Subst in_scope ids tvs cvs) v-  | isCoVar v = Subst in_scope ids tvs (delVarEnv cvs v)-  | isTyVar v = Subst in_scope ids (delVarEnv tvs v) cvs-  | otherwise = Subst in_scope (delVarEnv ids v) tvs cvs--delBndrs :: Subst -> [Var] -> Subst-delBndrs (Subst in_scope ids tvs cvs) vs-  = Subst in_scope (delVarEnvList ids vs) (delVarEnvList tvs vs) (delVarEnvList cvs vs)-      -- Easiest thing is just delete all from all!---- | Simultaneously substitute for a bunch of variables---   No left-right shadowing---   ie the substitution for   (\x \y. e) a1 a2---      so neither x nor y scope over a1 a2-mkOpenSubst :: InScopeSet -> [(Var,CoreArg)] -> Subst-mkOpenSubst in_scope pairs = Subst in_scope-                                   (mkVarEnv [(id,e)  | (id, e) <- pairs, isId id])-                                   (mkVarEnv [(tv,ty) | (tv, Type ty) <- pairs])-                                   (mkVarEnv [(v,co)  | (v, Coercion co) <- pairs])---------------------------------isInScope :: Var -> Subst -> Bool-isInScope v (Subst in_scope _ _ _) = v `elemInScopeSet` in_scope---- | Add the 'Var' to the in-scope set, but do not remove--- any existing substitutions for it-addInScopeSet :: Subst -> VarSet -> Subst-addInScopeSet (Subst in_scope ids tvs cvs) vs-  = Subst (in_scope `extendInScopeSetSet` vs) ids tvs cvs---- | Add the 'Var' to the in-scope set: as a side effect,--- and remove any existing substitutions for it-extendInScope :: Subst -> Var -> Subst-extendInScope (Subst in_scope ids tvs cvs) v-  = Subst (in_scope `extendInScopeSet` v)-          (ids `delVarEnv` v) (tvs `delVarEnv` v) (cvs `delVarEnv` v)---- | Add the 'Var's to the in-scope set: see also 'extendInScope'-extendInScopeList :: Subst -> [Var] -> Subst-extendInScopeList (Subst in_scope ids tvs cvs) vs-  = Subst (in_scope `extendInScopeSetList` vs)-          (ids `delVarEnvList` vs) (tvs `delVarEnvList` vs) (cvs `delVarEnvList` vs)---- | Optimized version of 'extendInScopeList' that can be used if you are certain--- all the things being added are 'Id's and hence none are 'TyVar's or 'CoVar's-extendInScopeIds :: Subst -> [Id] -> Subst-extendInScopeIds (Subst in_scope ids tvs cvs) vs-  = Subst (in_scope `extendInScopeSetList` vs)-          (ids `delVarEnvList` vs) tvs cvs--setInScope :: Subst -> InScopeSet -> Subst-setInScope (Subst _ ids tvs cvs) in_scope = Subst in_scope ids tvs cvs---- Pretty printing, for debugging only--instance Outputable Subst where-  ppr (Subst in_scope ids tvs cvs)-        =  text "<InScope =" <+> in_scope_doc-        $$ text " IdSubst   =" <+> ppr ids-        $$ text " TvSubst   =" <+> ppr tvs-        $$ text " CvSubst   =" <+> ppr cvs-         <> char '>'-    where-    in_scope_doc = pprVarSet (getInScopeVars in_scope) (braces . fsep . map ppr)--{--************************************************************************-*                                                                      *-        Substituting expressions-*                                                                      *-************************************************************************--}---- | Apply a substitution to an entire 'CoreExpr'. Remember, you may only--- apply the substitution /once/:--- See Note [Substitutions apply only once] in TyCoSubst------ Do *not* attempt to short-cut in the case of an empty substitution!--- See Note [Extending the Subst]-substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr-substExprSC doc subst orig_expr-  | isEmptySubst subst = orig_expr-  | otherwise          = -- pprTrace "enter subst-expr" (doc $$ ppr orig_expr) $-                         subst_expr doc subst orig_expr--substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr-substExpr doc subst orig_expr = subst_expr doc subst orig_expr--subst_expr :: SDoc -> Subst -> CoreExpr -> CoreExpr-subst_expr doc subst expr-  = go expr-  where-    go (Var v)         = lookupIdSubst (doc $$ text "subst_expr") subst v-    go (Type ty)       = Type (substTy subst ty)-    go (Coercion co)   = Coercion (substCo subst co)-    go (Lit lit)       = Lit lit-    go (App fun arg)   = App (go fun) (go arg)-    go (Tick tickish e) = mkTick (substTickish subst tickish) (go e)-    go (Cast e co)     = Cast (go e) (substCo subst co)-       -- Do not optimise even identity coercions-       -- Reason: substitution applies to the LHS of RULES, and-       --         if you "optimise" an identity coercion, you may-       --         lose a binder. We optimise the LHS of rules at-       --         construction time--    go (Lam bndr body) = Lam bndr' (subst_expr doc subst' body)-                       where-                         (subst', bndr') = substBndr subst bndr--    go (Let bind body) = Let bind' (subst_expr doc subst' body)-                       where-                         (subst', bind') = substBind subst bind--    go (Case scrut bndr ty alts) = Case (go scrut) bndr' (substTy subst ty) (map (go_alt subst') alts)-                                 where-                                 (subst', bndr') = substBndr subst bndr--    go_alt subst (con, bndrs, rhs) = (con, bndrs', subst_expr doc subst' rhs)-                                 where-                                   (subst', bndrs') = substBndrs subst bndrs---- | Apply a substitution to an entire 'CoreBind', additionally returning an updated 'Subst'--- that should be used by subsequent substitutions.-substBind, substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)--substBindSC subst bind    -- Short-cut if the substitution is empty-  | not (isEmptySubst subst)-  = substBind subst bind-  | otherwise-  = case bind of-       NonRec bndr rhs -> (subst', NonRec bndr' rhs)-          where-            (subst', bndr') = substBndr subst bndr-       Rec pairs -> (subst', Rec (bndrs' `zip` rhss'))-          where-            (bndrs, rhss)    = unzip pairs-            (subst', bndrs') = substRecBndrs subst bndrs-            rhss' | isEmptySubst subst'-                  = rhss-                  | otherwise-                  = map (subst_expr (text "substBindSC") subst') rhss--substBind subst (NonRec bndr rhs)-  = (subst', NonRec bndr' (subst_expr (text "substBind") subst rhs))-  where-    (subst', bndr') = substBndr subst bndr--substBind subst (Rec pairs)-   = (subst', Rec (bndrs' `zip` rhss'))-   where-       (bndrs, rhss)    = unzip pairs-       (subst', bndrs') = substRecBndrs subst bndrs-       rhss' = map (subst_expr (text "substBind") subst') rhss---- | De-shadowing the program is sometimes a useful pre-pass. It can be done simply--- by running over the bindings with an empty substitution, because substitution--- returns a result that has no-shadowing guaranteed.------ (Actually, within a single /type/ there might still be shadowing, because--- 'substTy' is a no-op for the empty substitution, but that's probably OK.)------ [Aug 09] This function is not used in GHC at the moment, but seems so---          short and simple that I'm going to leave it here-deShadowBinds :: CoreProgram -> CoreProgram-deShadowBinds binds = snd (mapAccumL substBind emptySubst binds)--{--************************************************************************-*                                                                      *-        Substituting binders-*                                                                      *-************************************************************************--Remember that substBndr and friends are used when doing expression-substitution only.  Their only business is substitution, so they-preserve all IdInfo (suitably substituted).  For example, we *want* to-preserve occ info in rules.--}---- | Substitutes a 'Var' for another one according to the 'Subst' given, returning--- the result and an updated 'Subst' that should be used by subsequent substitutions.--- 'IdInfo' is preserved by this process, although it is substituted into appropriately.-substBndr :: Subst -> Var -> (Subst, Var)-substBndr subst bndr-  | isTyVar bndr  = substTyVarBndr subst bndr-  | isCoVar bndr  = substCoVarBndr subst bndr-  | otherwise     = substIdBndr (text "var-bndr") subst subst bndr---- | Applies 'substBndr' to a number of 'Var's, accumulating a new 'Subst' left-to-right-substBndrs :: Subst -> [Var] -> (Subst, [Var])-substBndrs subst bndrs = mapAccumL substBndr subst bndrs---- | Substitute in a mutually recursive group of 'Id's-substRecBndrs :: Subst -> [Id] -> (Subst, [Id])-substRecBndrs subst bndrs-  = (new_subst, new_bndrs)-  where         -- Here's the reason we need to pass rec_subst to subst_id-    (new_subst, new_bndrs) = mapAccumL (substIdBndr (text "rec-bndr") new_subst) subst bndrs--substIdBndr :: SDoc-            -> Subst            -- ^ Substitution to use for the IdInfo-            -> Subst -> Id      -- ^ Substitution and Id to transform-            -> (Subst, Id)      -- ^ Transformed pair-                                -- NB: unfolding may be zapped--substIdBndr _doc rec_subst subst@(Subst in_scope env tvs cvs) old_id-  = -- pprTrace "substIdBndr" (doc $$ ppr old_id $$ ppr in_scope) $-    (Subst (in_scope `extendInScopeSet` new_id) new_env tvs cvs, new_id)-  where-    id1 = uniqAway in_scope old_id      -- id1 is cloned if necessary-    id2 | no_type_change = id1-        | otherwise      = setIdType id1 (substTy subst old_ty)--    old_ty = idType old_id-    no_type_change = (isEmptyVarEnv tvs && isEmptyVarEnv cvs) ||-                     noFreeVarsOfType old_ty--        -- new_id has the right IdInfo-        -- The lazy-set is because we're in a loop here, with-        -- rec_subst, when dealing with a mutually-recursive group-    new_id = maybeModifyIdInfo mb_new_info id2-    mb_new_info = substIdInfo rec_subst id2 (idInfo id2)-        -- NB: unfolding info may be zapped--        -- Extend the substitution if the unique has changed-        -- See the notes with substTyVarBndr for the delVarEnv-    new_env | no_change = delVarEnv env old_id-            | otherwise = extendVarEnv env old_id (Var new_id)--    no_change = id1 == old_id-        -- See Note [Extending the Subst]-        -- it's /not/ necessary to check mb_new_info and no_type_change--{--Now a variant that unconditionally allocates a new unique.-It also unconditionally zaps the OccInfo.--}---- | Very similar to 'substBndr', but it always allocates a new 'Unique' for--- each variable in its output.  It substitutes the IdInfo though.-cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)-cloneIdBndr subst us old_id-  = clone_id subst subst (old_id, uniqFromSupply us)---- | Applies 'cloneIdBndr' to a number of 'Id's, accumulating a final--- substitution from left to right-cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])-cloneIdBndrs subst us ids-  = mapAccumL (clone_id subst) subst (ids `zip` uniqsFromSupply us)--cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])--- Works for all kinds of variables (typically case binders)--- not just Ids-cloneBndrs subst us vs-  = mapAccumL (\subst (v, u) -> cloneBndr subst u v) subst (vs `zip` uniqsFromSupply us)--cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)-cloneBndr subst uniq v-  | isTyVar v = cloneTyVarBndr subst v uniq-  | otherwise = clone_id subst subst (v,uniq)  -- Works for coercion variables too---- | Clone a mutually recursive group of 'Id's-cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])-cloneRecIdBndrs subst us ids-  = (subst', ids')-  where-    (subst', ids') = mapAccumL (clone_id subst') subst-                               (ids `zip` uniqsFromSupply us)---- Just like substIdBndr, except that it always makes a new unique--- It is given the unique to use-clone_id    :: Subst                    -- Substitution for the IdInfo-            -> Subst -> (Id, Unique)    -- Substitution and Id to transform-            -> (Subst, Id)              -- Transformed pair--clone_id rec_subst subst@(Subst in_scope idvs tvs cvs) (old_id, uniq)-  = (Subst (in_scope `extendInScopeSet` new_id) new_idvs tvs new_cvs, new_id)-  where-    id1     = setVarUnique old_id uniq-    id2     = substIdType subst id1-    new_id  = maybeModifyIdInfo (substIdInfo rec_subst id2 (idInfo old_id)) id2-    (new_idvs, new_cvs) | isCoVar old_id = (idvs, extendVarEnv cvs old_id (mkCoVarCo new_id))-                        | otherwise      = (extendVarEnv idvs old_id (Var new_id), cvs)--{--************************************************************************-*                                                                      *-                Types and Coercions-*                                                                      *-************************************************************************--For types and coercions we just call the corresponding functions in-Type and Coercion, but we have to repackage the substitution, from a-Subst to a TCvSubst.--}--substTyVarBndr :: Subst -> TyVar -> (Subst, TyVar)-substTyVarBndr (Subst in_scope id_env tv_env cv_env) tv-  = case Type.substTyVarBndr (TCvSubst in_scope tv_env cv_env) tv of-        (TCvSubst in_scope' tv_env' cv_env', tv')-           -> (Subst in_scope' id_env tv_env' cv_env', tv')--cloneTyVarBndr :: Subst -> TyVar -> Unique -> (Subst, TyVar)-cloneTyVarBndr (Subst in_scope id_env tv_env cv_env) tv uniq-  = case Type.cloneTyVarBndr (TCvSubst in_scope tv_env cv_env) tv uniq of-        (TCvSubst in_scope' tv_env' cv_env', tv')-           -> (Subst in_scope' id_env tv_env' cv_env', tv')--substCoVarBndr :: Subst -> TyVar -> (Subst, TyVar)-substCoVarBndr (Subst in_scope id_env tv_env cv_env) cv-  = case Coercion.substCoVarBndr (TCvSubst in_scope tv_env cv_env) cv of-        (TCvSubst in_scope' tv_env' cv_env', cv')-           -> (Subst in_scope' id_env tv_env' cv_env', cv')---- | See 'Type.substTy'-substTy :: Subst -> Type -> Type-substTy subst ty = Type.substTyUnchecked (getTCvSubst subst) ty--getTCvSubst :: Subst -> TCvSubst-getTCvSubst (Subst in_scope _ tenv cenv) = TCvSubst in_scope tenv cenv---- | See 'Coercion.substCo'-substCo :: HasCallStack => Subst -> Coercion -> Coercion-substCo subst co = Coercion.substCo (getTCvSubst subst) co--{--************************************************************************-*                                                                      *-\section{IdInfo substitution}-*                                                                      *-************************************************************************--}--substIdType :: Subst -> Id -> Id-substIdType subst@(Subst _ _ tv_env cv_env) id-  | (isEmptyVarEnv tv_env && isEmptyVarEnv cv_env) || noFreeVarsOfType old_ty = id-  | otherwise   = setIdType id (substTy subst old_ty)-                -- The tyCoVarsOfType is cheaper than it looks-                -- because we cache the free tyvars of the type-                -- in a Note in the id's type itself-  where-    old_ty = idType id----------------------- | Substitute into some 'IdInfo' with regard to the supplied new 'Id'.-substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo-substIdInfo subst new_id info-  | nothing_to_do = Nothing-  | otherwise     = Just (info `setRuleInfo`      substSpec subst new_id old_rules-                               `setUnfoldingInfo` substUnfolding subst old_unf)-  where-    old_rules     = ruleInfo info-    old_unf       = unfoldingInfo info-    nothing_to_do = isEmptyRuleInfo old_rules && not (isFragileUnfolding old_unf)----------------------- | Substitutes for the 'Id's within an unfolding-substUnfolding, substUnfoldingSC :: Subst -> Unfolding -> Unfolding-        -- Seq'ing on the returned Unfolding is enough to cause-        -- all the substitutions to happen completely--substUnfoldingSC subst unf       -- Short-cut version-  | isEmptySubst subst = unf-  | otherwise          = substUnfolding subst unf--substUnfolding subst df@(DFunUnfolding { df_bndrs = bndrs, df_args = args })-  = df { df_bndrs = bndrs', df_args = args' }-  where-    (subst',bndrs') = substBndrs subst bndrs-    args'           = map (substExpr (text "subst-unf:dfun") subst') args--substUnfolding subst unf@(CoreUnfolding { uf_tmpl = tmpl, uf_src = src })-        -- Retain an InlineRule!-  | not (isStableSource src)  -- Zap an unstable unfolding, to save substitution work-  = NoUnfolding-  | otherwise                 -- But keep a stable one!-  = seqExpr new_tmpl `seq`-    unf { uf_tmpl = new_tmpl }-  where-    new_tmpl = substExpr (text "subst-unf") subst tmpl--substUnfolding _ unf = unf      -- NoUnfolding, OtherCon---------------------substIdOcc :: Subst -> Id -> Id--- These Ids should not be substituted to non-Ids-substIdOcc subst v = case lookupIdSubst (text "substIdOcc") subst v of-                        Var v' -> v'-                        other  -> pprPanic "substIdOcc" (vcat [ppr v <+> ppr other, ppr subst])----------------------- | Substitutes for the 'Id's within the 'WorkerInfo' given the new function 'Id'-substSpec :: Subst -> Id -> RuleInfo -> RuleInfo-substSpec subst new_id (RuleInfo rules rhs_fvs)-  = seqRuleInfo new_spec `seq` new_spec-  where-    subst_ru_fn = const (idName new_id)-    new_spec = RuleInfo (map (substRule subst subst_ru_fn) rules)-                        (substDVarSet subst rhs_fvs)---------------------substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]-substRulesForImportedIds subst rules-  = map (substRule subst not_needed) rules-  where-    not_needed name = pprPanic "substRulesForImportedIds" (ppr name)---------------------substRule :: Subst -> (Name -> Name) -> CoreRule -> CoreRule---- The subst_ru_fn argument is applied to substitute the ru_fn field--- of the rule:---    - Rules for *imported* Ids never change ru_fn---    - Rules for *local* Ids are in the IdInfo for that Id,---      and the ru_fn field is simply replaced by the new name---      of the Id-substRule _ _ rule@(BuiltinRule {}) = rule-substRule subst subst_ru_fn rule@(Rule { ru_bndrs = bndrs, ru_args = args-                                       , ru_fn = fn_name, ru_rhs = rhs-                                       , ru_local = is_local })-  = rule { ru_bndrs = bndrs'-         , ru_fn    = if is_local-                        then subst_ru_fn fn_name-                        else fn_name-         , ru_args  = map (substExpr doc subst') args-         , ru_rhs   = substExpr (text "foo") subst' rhs }-           -- Do NOT optimise the RHS (previously we did simplOptExpr here)-           -- See Note [Substitute lazily]-  where-    doc = text "subst-rule" <+> ppr fn_name-    (subst', bndrs') = substBndrs subst bndrs---------------------substDVarSet :: Subst -> DVarSet -> DVarSet-substDVarSet subst fvs-  = mkDVarSet $ fst $ foldr (subst_fv subst) ([], emptyVarSet) $ dVarSetElems fvs-  where-  subst_fv subst fv acc-     | isId fv = expr_fvs (lookupIdSubst (text "substDVarSet") subst fv) isLocalVar emptyVarSet $! acc-     | otherwise = tyCoFVsOfType (lookupTCvSubst subst fv) (const True) emptyVarSet $! acc---------------------substTickish :: Subst -> Tickish Id -> Tickish Id-substTickish subst (Breakpoint n ids)-   = Breakpoint n (map do_one ids)- where-    do_one = getIdFromTrivialExpr . lookupIdSubst (text "subst_tickish") subst-substTickish _subst other = other--{- Note [Substitute lazily]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-The functions that substitute over IdInfo must be pretty lazy, because-they are knot-tied by substRecBndrs.--One case in point was #10627 in which a rule for a function 'f'-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>>.--In any case we don't need to optimise the RHS of rules, or unfoldings,-because the simplifier will do that.---Note [substTickish]-~~~~~~~~~~~~~~~~~~~~~~-A Breakpoint contains a list of Ids.  What happens if we ever want to-substitute an expression for one of these Ids?--First, we ensure that we only ever substitute trivial expressions for-these Ids, by marking them as NoOccInfo in the occurrence analyser.-Then, when substituting for the Id, we unwrap any type applications-and abstractions to get back to an Id, with getIdFromTrivialExpr.--Second, we have to ensure that we never try to substitute a literal-for an Id in a breakpoint.  We ensure this by never storing an Id with-an unlifted type in a Breakpoint - see Coverage.mkTickish.-Breakpoints can't handle free variables with unlifted types anyway.--}--{--Note [Worker inlining]-~~~~~~~~~~~~~~~~~~~~~~-A worker can get substituted away entirely.-        - it might be trivial-        - it might simply be very small-We do not treat an InlWrapper as an 'occurrence' in the occurrence-analyser, so it's possible that the worker is not even in scope any more.--In all all these cases we simply drop the special case, returning to-InlVanilla.  The WARN is just so I can see if it happens a lot.--}-

− compiler/coreSyn/CoreSyn.hs

@@ -1,2349 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--}--{-# LANGUAGE CPP, DeriveDataTypeable, FlexibleContexts #-}-{-# LANGUAGE NamedFieldPuns #-}-{-# LANGUAGE BangPatterns #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}-{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}---- | CoreSyn holds all the main data types for use by for the Glasgow Haskell Compiler midsection-module CoreSyn (-        -- * Main data types-        Expr(..), Alt, Bind(..), AltCon(..), Arg,-        Tickish(..), TickishScoping(..), TickishPlacement(..),-        CoreProgram, CoreExpr, CoreAlt, CoreBind, CoreArg, CoreBndr,-        TaggedExpr, TaggedAlt, TaggedBind, TaggedArg, TaggedBndr(..), deTagExpr,--        -- * In/Out type synonyms-        InId, InBind, InExpr, InAlt, InArg, InType, InKind,-               InBndr, InVar, InCoercion, InTyVar, InCoVar,-        OutId, OutBind, OutExpr, OutAlt, OutArg, OutType, OutKind,-               OutBndr, OutVar, OutCoercion, OutTyVar, OutCoVar, MOutCoercion,--        -- ** 'Expr' construction-        mkLet, mkLets, mkLetNonRec, mkLetRec, mkLams,-        mkApps, mkTyApps, mkCoApps, mkVarApps, mkTyArg,--        mkIntLit, mkIntLitInt,-        mkWordLit, mkWordLitWord,-        mkWord64LitWord64, mkInt64LitInt64,-        mkCharLit, mkStringLit,-        mkFloatLit, mkFloatLitFloat,-        mkDoubleLit, mkDoubleLitDouble,--        mkConApp, mkConApp2, mkTyBind, mkCoBind,-        varToCoreExpr, varsToCoreExprs,--        isId, cmpAltCon, cmpAlt, ltAlt,--        -- ** Simple 'Expr' access functions and predicates-        bindersOf, bindersOfBinds, rhssOfBind, rhssOfAlts,-        collectBinders, collectTyBinders, collectTyAndValBinders,-        collectNBinders,-        collectArgs, stripNArgs, collectArgsTicks, flattenBinds,--        exprToType, exprToCoercion_maybe,-        applyTypeToArg,--        isValArg, isTypeArg, isCoArg, isTyCoArg, valArgCount, valBndrCount,-        isRuntimeArg, isRuntimeVar,--        -- * Tick-related functions-        tickishCounts, tickishScoped, tickishScopesLike, tickishFloatable,-        tickishCanSplit, mkNoCount, mkNoScope,-        tickishIsCode, tickishPlace,-        tickishContains,--        -- * Unfolding data types-        Unfolding(..),  UnfoldingGuidance(..), UnfoldingSource(..),--        -- ** Constructing 'Unfolding's-        noUnfolding, bootUnfolding, evaldUnfolding, mkOtherCon,-        unSaturatedOk, needSaturated, boringCxtOk, boringCxtNotOk,--        -- ** Predicates and deconstruction on 'Unfolding'-        unfoldingTemplate, expandUnfolding_maybe,-        maybeUnfoldingTemplate, otherCons,-        isValueUnfolding, isEvaldUnfolding, isCheapUnfolding,-        isExpandableUnfolding, isConLikeUnfolding, isCompulsoryUnfolding,-        isStableUnfolding, isFragileUnfolding, hasSomeUnfolding,-        isBootUnfolding,-        canUnfold, neverUnfoldGuidance, isStableSource,--        -- * Annotated expression data types-        AnnExpr, AnnExpr'(..), AnnBind(..), AnnAlt,--        -- ** Operations on annotated expressions-        collectAnnArgs, collectAnnArgsTicks,--        -- ** Operations on annotations-        deAnnotate, deAnnotate', deAnnAlt, deAnnBind,-        collectAnnBndrs, collectNAnnBndrs,--        -- * Orphanhood-        IsOrphan(..), isOrphan, notOrphan, chooseOrphanAnchor,--        -- * Core rule data types-        CoreRule(..), RuleBase,-        RuleName, RuleFun, IdUnfoldingFun, InScopeEnv,-        RuleEnv(..), mkRuleEnv, emptyRuleEnv,--        -- ** Operations on 'CoreRule's-        ruleArity, ruleName, ruleIdName, ruleActivation,-        setRuleIdName, ruleModule,-        isBuiltinRule, isLocalRule, isAutoRule,-    ) where--#include "HsVersions.h"--import GhcPrelude--import CostCentre-import VarEnv( InScopeSet )-import Var-import Type-import Coercion-import Name-import NameSet-import NameEnv( NameEnv, emptyNameEnv )-import Literal-import DataCon-import Module-import BasicTypes-import DynFlags-import Outputable-import Util-import UniqSet-import SrcLoc     ( RealSrcSpan, containsSpan )-import Binary--import Data.Data hiding (TyCon)-import Data.Int-import Data.Word--infixl 4 `mkApps`, `mkTyApps`, `mkVarApps`, `App`, `mkCoApps`--- Left associative, so that we can say (f `mkTyApps` xs `mkVarApps` ys)--{--************************************************************************-*                                                                      *-\subsection{The main data types}-*                                                                      *-************************************************************************--These data types are the heart of the compiler--}---- | This is the data type that represents GHCs core intermediate language. Currently--- GHC uses System FC <https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/> for this purpose,--- which is closely related to the simpler and better known System F <http://en.wikipedia.org/wiki/System_F>.------ We get from Haskell source to this Core language in a number of stages:------ 1. The source code is parsed into an abstract syntax tree, which is represented---    by the data type 'GHC.Hs.Expr.HsExpr' with the names being 'RdrName.RdrNames'------ 2. This syntax tree is /renamed/, which attaches a 'Unique.Unique' to every 'RdrName.RdrName'---    (yielding a 'Name.Name') to disambiguate identifiers which are lexically identical.---    For example, this program:------ @---      f x = let f x = x + 1---            in f (x - 2)--- @------    Would be renamed by having 'Unique's attached so it looked something like this:------ @---      f_1 x_2 = let f_3 x_4 = x_4 + 1---                in f_3 (x_2 - 2)--- @---    But see Note [Shadowing] below.------ 3. The resulting syntax tree undergoes type checking (which also deals with instantiating---    type class arguments) to yield a 'GHC.Hs.Expr.HsExpr' type that has 'Id.Id' as it's names.------ 4. Finally the syntax tree is /desugared/ from the expressive 'GHC.Hs.Expr.HsExpr' type into---    this 'Expr' type, which has far fewer constructors and hence is easier to perform---    optimization, analysis and code generation on.------ The type parameter @b@ is for the type of binders in the expression tree.------ The language consists of the following elements:------ *  Variables---    See Note [Variable occurrences in Core]------ *  Primitive literals------ *  Applications: note that the argument may be a 'Type'.---    See Note [CoreSyn let/app invariant]---    See Note [Levity polymorphism invariants]------ *  Lambda abstraction---    See Note [Levity polymorphism invariants]------ *  Recursive and non recursive @let@s. Operationally---    this corresponds to allocating a thunk for the things---    bound and then executing the sub-expression.------    See Note [CoreSyn letrec invariant]---    See Note [CoreSyn let/app invariant]---    See Note [Levity polymorphism invariants]---    See Note [CoreSyn type and coercion invariant]------ *  Case expression. Operationally this corresponds to evaluating---    the scrutinee (expression examined) to weak head normal form---    and then examining at most one level of resulting constructor (i.e. you---    cannot do nested pattern matching directly with this).------    The binder gets bound to the value of the scrutinee,---    and the 'Type' must be that of all the case alternatives------    IMPORTANT: see Note [Case expression invariants]------ *  Cast an expression to a particular type.---    This is used to implement @newtype@s (a @newtype@ constructor or---    destructor just becomes a 'Cast' in Core) and GADTs.------ *  Notes. These allow general information to be added to expressions---    in the syntax tree------ *  A type: this should only show up at the top level of an Arg------ *  A coercion--{- Note [Why does Case have a 'Type' field?]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The obvious alternative is-   exprType (Case scrut bndr alts)-     | (_,_,rhs1):_ <- alts-     = exprType rhs1--But caching the type in the Case constructor-  exprType (Case scrut bndr ty alts) = ty-is better for at least three reasons:--* It works when there are no alternatives (see case invariant 1 above)--* It might be faster in deeply-nested situations.--* It might not be quite the same as (exprType rhs) for one-  of the RHSs in alts. Consider a phantom type synonym-       type S a = Int-   and we want to form the case expression-        case x of { K (a::*) -> (e :: S a) }-   Then exprType of the RHS is (S a), but we cannot make that be-   the 'ty' in the Case constructor because 'a' is simply not in-   scope there. Instead we must expand the synonym to Int before-   putting it in the Case constructor.  See CoreUtils.mkSingleAltCase.--   So we'd have to do synonym expansion in exprType which would-   be inefficient.--* The type stored in the case is checked with lintInTy. This checks-  (among other things) that it does not mention any variables that are-  not in scope. If we did not have the type there, it would be a bit-  harder for Core Lint to reject case blah of Ex x -> x where-      data Ex = forall a. Ex a.--}---- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-data Expr b-  = Var   Id-  | Lit   Literal-  | App   (Expr b) (Arg b)-  | Lam   b (Expr b)-  | Let   (Bind b) (Expr b)-  | Case  (Expr b) b Type [Alt b]   -- See Note [Case expression invariants]-                                    -- and Note [Why does Case have a 'Type' field?]-  | Cast  (Expr b) Coercion-  | Tick  (Tickish Id) (Expr b)-  | Type  Type-  | Coercion Coercion-  deriving Data---- | Type synonym for expressions that occur in function argument positions.--- Only 'Arg' should contain a 'Type' at top level, general 'Expr' should not-type Arg b = Expr b---- | A case split alternative. Consists of the constructor leading to the alternative,--- the variables bound from the constructor, and the expression to be executed given that binding.--- The default alternative is @(DEFAULT, [], rhs)@---- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-type Alt b = (AltCon, [b], Expr b)---- | A case alternative constructor (i.e. pattern match)---- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-data AltCon-  = DataAlt DataCon   --  ^ A plain data constructor: @case e of { Foo x -> ... }@.-                      -- Invariant: the 'DataCon' is always from a @data@ type, and never from a @newtype@--  | LitAlt  Literal   -- ^ A literal: @case e of { 1 -> ... }@-                      -- Invariant: always an *unlifted* literal-                      -- See Note [Literal alternatives]--  | 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--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-data Bind b = NonRec b (Expr b)-            | Rec [(b, (Expr b))]-  deriving Data--{--Note [Shadowing]-~~~~~~~~~~~~~~~~-While various passes attempt to rename on-the-fly in a manner that-avoids "shadowing" (thereby simplifying downstream optimizations),-neither the simplifier nor any other pass GUARANTEES that shadowing is-avoided. Thus, all passes SHOULD work fine even in the presence of-arbitrary shadowing in their inputs.--In particular, scrutinee variables `x` in expressions of the form-`Case e x t` are often renamed to variables with a prefix-"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 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-shadowing, you can give a new Unique to an Id without changing its-printable name, which makes debugging easier.--Note [Literal alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-Literal alternatives (LitAlt lit) are always for *un-lifted* literals.-We have one literal, a literal Integer, that is lifted, and we don't-allow in a LitAlt, because LitAlt cases don't do any evaluation. Also-(see #5603) if you say-    case 3 of-      S# x -> ...-      J# _ _ -> ...-(where S#, J# are the constructors for Integer) we don't want the-simplifier calling findAlt with argument (LitAlt 3).  No no.  Integer-literals are an opaque encoding of an algebraic data type, not of-an unlifted literal, like all the others.--Also, we do not permit case analysis with literal patterns on floating-point-types. See #9238 and Note [Rules for floating-point comparisons] in-PrelRules for the rationale for this restriction.---------------------------- CoreSyn INVARIANTS -----------------------------Note [Variable occurrences in Core]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Variable /occurrences/ are never CoVars, though /bindings/ can be.-All CoVars appear in Coercions.--For example-  \(c :: Age~#Int) (d::Int). d |> (sym c)-Here 'c' is a CoVar, which is lambda-bound, but it /occurs/ in-a Coercion, (sym c).--Note [CoreSyn letrec invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The right hand sides of all top-level and recursive @let@s-/must/ be of lifted type (see "Type#type_classification" for-the meaning of /lifted/ vs. /unlifted/).--There is one exception to this rule, top-level @let@s are-allowed to bind primitive string literals: see-Note [CoreSyn top-level string literals].--Note [CoreSyn top-level string literals]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-As an exception to the usual rule that top-level binders must be lifted,-we allow binding primitive string literals (of type Addr#) of type Addr# at the-top level. This allows us to share string literals earlier in the pipeline and-crucially allows other optimizations in the Core2Core pipeline to fire.-Consider,--  f n = let a::Addr# = "foo"#-        in \x -> blah--In order to be able to inline `f`, we would like to float `a` to the top.-Another option would be to inline `a`, but that would lead to duplicating string-literals, which we want to avoid. See #8472.--The solution is simply to allow top-level unlifted binders. We can't allow-arbitrary unlifted expression at the top-level though, unlifted binders cannot-be thunks, so we just allow string literals.--We allow the top-level primitive string literals to be wrapped in Ticks-in the same way they can be wrapped when nested in an expression.-CoreToSTG currently discards Ticks around top-level primitive string literals.-See #14779.--Also see Note [Compilation plan for top-level string literals].--Note [Compilation plan for top-level string literals]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Here is a summary on how top-level string literals are handled by various-parts of the compilation pipeline.--* In the source language, there is no way to bind a primitive string literal-  at the top level.--* In Core, we have a special rule that permits top-level Addr# bindings. See-  Note [CoreSyn top-level string literals]. Core-to-core passes may introduce-  new top-level string literals.--* In STG, top-level string literals are explicitly represented in the syntax-  tree.--* A top-level string literal may end up exported from a module. In this case,-  in the object file, the content of the exported literal is given a label with-  the _bytes suffix.--Note [CoreSyn let/app invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The let/app invariant-     the right hand side of a non-recursive 'Let', and-     the argument of an 'App',-    /may/ be of unlifted type, but only if-    the expression is ok-for-speculation-    or the 'Let' is for a join point.--This means that the let can be floated around-without difficulty. For example, this is OK:--   y::Int# = x +# 1#--But this is not, as it may affect termination if the-expression is floated out:--   y::Int# = fac 4#--In this situation you should use @case@ rather than a @let@. The function-'CoreUtils.needsCaseBinding' can help you determine which to generate, or-alternatively use 'MkCore.mkCoreLet' rather than this constructor directly,-which will generate a @case@ if necessary--The let/app invariant is initially enforced by mkCoreLet and mkCoreApp in-coreSyn/MkCore.--For discussion of some implications of the let/app invariant primops see-Note [Checking versus non-checking primops] in PrimOp.--Note [Case expression invariants]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Case expressions are one of the more complicated elements of the Core-language, and come with a number of invariants.  All of them should be-checked by Core Lint.--1. The list of alternatives may be empty;-   See Note [Empty case alternatives]--2. The 'DEFAULT' case alternative must be first in the list,-   if it occurs at all.  Checked in CoreLint.checkCaseAlts.--3. The remaining cases are in order of (strictly) increasing-     tag  (for 'DataAlts') or-     lit  (for 'LitAlts').-   This makes finding the relevant constructor easy, and makes-   comparison easier too.   Checked in CoreLint.checkCaseAlts.--4. The list of alternatives must be exhaustive. An /exhaustive/ case-   does not necessarily mention all constructors:--   @-        data Foo = Red | Green | Blue-        ... case x of-              Red   -> True-              other -> f (case x of-                              Green -> ...-                              Blue  -> ... ) ...-   @--   The inner case does not need a @Red@ alternative, because @x@-   can't be @Red@ at that program point.--   This is not checked by Core Lint -- it's very hard to do so.-   E.g. suppose that inner case was floated out, thus:-         let a = case x of-                   Green -> ...-                   Blue  -> ... )-         case x of-           Red   -> True-           other -> f a-   Now it's really hard to see that the Green/Blue case is-   exhaustive.  But it is.--   If you have a case-expression that really /isn't/ exhaustive,-   we may generate seg-faults.  Consider the Green/Blue case-   above.  Since there are only two branches we may generate-   code that tests for Green, and if not Green simply /assumes/-   Blue (since, if the case is exhaustive, that's all that-   remains).  Of course, if it's not Blue and we start fetching-   fields that should be in a Blue constructor, we may die-   horribly. See also Note [Core Lint guarantee] in CoreLint.--5. Floating-point values must not be scrutinised against literals.-   See #9238 and Note [Rules for floating-point comparisons]-   in PrelRules for rationale.  Checked in lintCaseExpr;-   see the call to isFloatingTy.--6. The 'ty' field of (Case scrut bndr ty alts) is the type of the-   /entire/ case expression.  Checked in lintAltExpr.-   See also Note [Why does Case have a 'Type' field?].--7. The type of the scrutinee must be the same as the type-   of the case binder, obviously.  Checked in lintCaseExpr.--Note [CoreSyn type and coercion invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We allow a /non-recursive/, /non-top-level/ let to bind type and-coercion variables.  These can be very convenient for postponing type-substitutions until the next run of the simplifier.--* A type variable binding must have a RHS of (Type ty)--* A coercion variable binding must have a RHS of (Coercion co)--  It is possible to have terms that return a coercion, but we use-  case-binding for those; e.g.-     case (eq_sel d) of (co :: a ~# b) -> blah-  where eq_sel :: (a~b) -> (a~#b)--  Or even even-      case (df @Int) of (co :: a ~# b) -> blah-  Which is very exotic, and I think never encountered; but see-  Note [Equality superclasses in quantified constraints]-  in TcCanonical--Note [CoreSyn case invariants]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-See #case_invariants#--Note [Levity polymorphism invariants]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-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-     (see Note [Invariants on join points])--* The type of the argument of an App must not be levity-polymorphic.--A type (t::TYPE r) is "levity polymorphic" if 'r' has any free variables.--For example-  \(r::RuntimeRep). \(a::TYPE r). \(x::a). e-is illegal because x's type has kind (TYPE r), which has 'r' free.--See Note [Levity polymorphism checking] in DsMonad to see where these-invariants are established for user-written code.--Note [CoreSyn let goal]-~~~~~~~~~~~~~~~~~~~~~~~-* The simplifier tries to ensure that if the RHS of a let is a constructor-  application, its arguments are trivial, so that the constructor can be-  inlined vigorously.--Note [Type let]-~~~~~~~~~~~~~~~-See #type_let#--Note [Empty case alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The alternatives of a case expression should be exhaustive.  But-this exhaustive list can be empty!--* A case expression can have empty alternatives if (and only if) the-  scrutinee is bound to raise an exception or diverge. When do we know-  this?  See Note [Bottoming expressions] in CoreUtils.--* The possibility of empty alternatives is one reason we need a type on-  the case expression: if the alternatives are empty we can't get the-  type from the alternatives!--* In the case of empty types (see Note [Bottoming expressions]), say-    data T-  we do NOT want to replace-    case (x::T) of Bool {}   -->   error Bool "Inaccessible case"-  because x might raise an exception, and *that*'s what we want to see!-  (#6067 is an example.) To preserve semantics we'd have to say-     x `seq` error Bool "Inaccessible case"-  but the 'seq' is just a case, so we are back to square 1.  Or I suppose-  we could say-     x |> UnsafeCoerce T Bool-  but that loses all trace of the fact that this originated with an empty-  set of alternatives.--* We can use the empty-alternative construct to coerce error values from-  one type to another.  For example--    f :: Int -> Int-    f n = error "urk"--    g :: Int -> (# Char, Bool #)-    g x = case f x of { 0 -> ..., n -> ... }--  Then if we inline f in g's RHS we get-    case (error Int "urk") of (# Char, Bool #) { ... }-  and we can discard the alternatives since the scrutinee is bottom to give-    case (error Int "urk") of (# Char, Bool #) {}--  This is nicer than using an unsafe coerce between Int ~ (# Char,Bool #),-  if for no other reason that we don't need to instantiate the (~) at an-  unboxed type.--* We treat a case expression with empty alternatives as trivial iff-  its scrutinee is (see CoreUtils.exprIsTrivial).  This is actually-  important; see Note [Empty case is trivial] in CoreUtils--* An empty case is replaced by its scrutinee during the CoreToStg-  conversion; remember STG is un-typed, so there is no need for-  the empty case to do the type conversion.--Note [Join points]-~~~~~~~~~~~~~~~~~~-In Core, a *join point* is a specially tagged function whose only occurrences-are saturated tail calls. A tail call can appear in these places:--  1. In the branches (not the scrutinee) of a case-  2. Underneath a let (value or join point)-  3. Inside another join point--We write a join-point declaration as-  join j @a @b x y = e1 in e2,-like a let binding but with "join" instead (or "join rec" for "let rec"). Note-that we put the parameters before the = rather than using lambdas; this is-because it's relevant how many parameters the join point takes *as a join-point.* This number is called the *join arity,* distinct from arity because it-counts types as well as values. Note that a join point may return a lambda! So-  join j x = x + 1-is different from-  join j = \x -> x + 1-The former has join arity 1, while the latter has join arity 0.--The identifier for a join point is called a join id or a *label.* An invocation-is called a *jump.* We write a jump using the jump keyword:--  jump j 3--The words *label* and *jump* are evocative of assembly code (or Cmm) for a-reason: join points are indeed compiled as labeled blocks, and jumps become-actual jumps (plus argument passing and stack adjustment). There is no closure-allocated and only a fraction of the function-call overhead. Hence we would-like as many functions as possible to become join points (see OccurAnal) and-the type rules for join points ensure we preserve the properties that make them-efficient.--In the actual AST, a join point is indicated by the IdDetails of the binder: a-local value binding gets 'VanillaId' but a join point gets a 'JoinId' with its-join arity.--For more details, see the paper:--  Luke Maurer, Paul Downen, Zena Ariola, and Simon Peyton Jones. "Compiling-  without continuations." Submitted to PLDI'17.--  https://www.microsoft.com/en-us/research/publication/compiling-without-continuations/--Note [Invariants on join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Join points must follow these invariants:--  1. All occurrences must be tail calls. Each of these tail calls must pass the-     same number of arguments, counting both types and values; we call this the-     "join arity" (to distinguish from regular arity, which only counts values).--     See Note [Join points are less general than the paper]--  2. For join arity n, the right-hand side must begin with at least n lambdas.-     No ticks, no casts, just lambdas!  C.f. CoreUtils.joinRhsArity.--     2a. Moreover, this same constraint applies to any unfolding of-         the binder.  Reason: if we want to push a continuation into-         the RHS we must push it into the unfolding as well.--     2b. The Arity (in the IdInfo) of a join point is the number of value-         binders in the top n lambdas, where n is the join arity.--         So arity <= join arity; the former counts only value binders-         while the latter counts all binders.-         e.g. Suppose $j has join arity 1-               let j = \x y. e in case x of { A -> j 1; B -> j 2 }-         Then its ordinary arity is also 1, not 2.--         The arity of a join point isn't very important; but short of setting-         it to zero, it is helpful to have an invariant.  E.g. #17294.--  3. If the binding is recursive, then all other bindings in the recursive group-     must also be join points.--  4. The binding's type must not be polymorphic in its return type (as defined-     in Note [The polymorphism rule of join points]).--However, join points have simpler invariants in other ways--  5. A join point can have an unboxed type without the RHS being-     ok-for-speculation (i.e. drop the let/app invariant)-     e.g.  let j :: Int# = factorial x in ...--  6. A join point can have a levity-polymorphic RHS-     e.g.  let j :: r :: TYPE l = fail void# in ...-     This happened in an intermediate program #13394--Examples:--  join j1  x = 1 + x in jump j (jump j x)  -- Fails 1: non-tail call-  join j1' x = 1 + x in if even a-                          then jump j1 a-                          else jump j1 a b -- Fails 1: inconsistent calls-  join j2  x = flip (+) x in j2 1 2        -- Fails 2: not enough lambdas-  join j2' x = \y -> x + y in j3 1         -- Passes: extra lams ok-  join j @a (x :: a) = x                   -- Fails 4: polymorphic in ret type--Invariant 1 applies to left-hand sides of rewrite rules, so a rule for a join-point must have an exact call as its LHS.--Strictly speaking, invariant 3 is redundant, since a call from inside a lazy-binding isn't a tail call. Since a let-bound value can't invoke a free join-point, then, they can't be mutually recursive. (A Core binding group *can*-include spurious extra bindings if the occurrence analyser hasn't run, so-invariant 3 does still need to be checked.) For the rigorous definition of-"tail call", see Section 3 of the paper (Note [Join points]).--Invariant 4 is subtle; see Note [The polymorphism rule of join points].--Invariant 6 is to enable code like this:--  f = \(r :: RuntimeRep) (a :: TYPE r) (x :: T).-      join j :: a-           j = error @r @a "bloop"-      in case x of-           A -> j-           B -> j-           C -> error @r @a "blurp"--Core Lint will check these invariants, anticipating that any binder whose-OccInfo is marked AlwaysTailCalled will become a join point as soon as the-simplifier (or simpleOptPgm) runs.--Note [Join points are less general than the paper]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In the paper "Compiling without continuations", this expression is-perfectly valid:--    join { j = \_ -> e }-    in (case blah of       )-       (  True  -> j void# ) arg-       (  False -> blah    )--assuming 'j' has arity 1.   Here the call to 'j' does not look like a-tail call, but actually everything is fine. See Section 3, "Managing \Delta"-in the paper.--In GHC, however, we adopt a slightly more restrictive subset, in which-join point calls must be tail calls.  I think we /could/ loosen it up, but-in fact the simplifier ensures that we always get tail calls, and it makes-the back end a bit easier I think.  Generally, just less to think about;-nothing deeper than that.--Note [The type of a join point]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A join point has the same type it would have as a function. That is, if it takes-an Int and a Bool and its body produces a String, its type is `Int -> Bool ->-String`. Natural as this may seem, it can be awkward. A join point shouldn't be-thought to "return" in the same sense a function does---a jump is one-way. This-is crucial for understanding how case-of-case interacts with join points:--  case (join-          j :: Int -> Bool -> String-          j x y = ...-        in-          jump j z w) of-    "" -> True-    _  -> False--The simplifier will pull the case into the join point (see Note [Case-of-case-and join points] in Simplify):--  join-    j :: Int -> Bool -> Bool -- changed!-    j x y = case ... of "" -> True-                        _  -> False-  in-    jump j z w--The body of the join point now returns a Bool, so the label `j` has to have its-type updated accordingly. Inconvenient though this may be, it has the advantage-that 'CoreUtils.exprType' can still return a type for any expression, including-a jump.--This differs from the paper (see Note [Invariants on join points]). In the-paper, we instead give j the type `Int -> Bool -> forall a. a`. Then each jump-carries the "return type" as a parameter, exactly the way other non-returning-functions like `error` work:--  case (join-          j :: Int -> Bool -> forall a. a-          j x y = ...-        in-          jump j z w @String) of-    "" -> True-    _  -> False--Now we can move the case inward and we only have to change the jump:--  join-    j :: Int -> Bool -> forall a. a-    j x y = case ... of "" -> True-                        _  -> False-  in-    jump j z w @Bool--(Core Lint would still check that the body of the join point has the right type;-that type would simply not be reflected in the join id.)--Note [The polymorphism rule of join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Invariant 4 of Note [Invariants on join points] forbids a join point to be-polymorphic in its return type. That is, if its type is--  forall a1 ... ak. t1 -> ... -> tn -> r--where its join arity is k+n, none of the type parameters ai may occur free in r.--In some way, this falls out of the fact that given--  join-     j @a1 ... @ak x1 ... xn = e1-  in e2--then all calls to `j` are in tail-call positions of `e`, and expressions in-tail-call positions in `e` have the same type as `e`.-Therefore the type of `e1` -- the return type of the join point -- must be the-same as the type of e2.-Since the type variables aren't bound in `e2`, its type can't include them, and-thus neither can the type of `e1`.--This unfortunately prevents the `go` in the following code from being a-join-point:--  iter :: forall a. Int -> (a -> a) -> a -> a-  iter @a n f x = go @a n f x-    where-      go :: forall a. Int -> (a -> a) -> a -> a-      go @a 0 _ x = x-      go @a n f x = go @a (n-1) f (f x)--In this case, a static argument transformation would fix that (see-ticket #14620):--  iter :: forall a. Int -> (a -> a) -> a -> a-  iter @a n f x = go' @a n f x-    where-      go' :: Int -> (a -> a) -> a -> a-      go' 0 _ x = x-      go' n f x = go' (n-1) f (f x)--In general, loopification could be employed to do that (see #14068.)--Can we simply drop the requirement, and allow `go` to be a join-point? We-could, and it would work. But we could not longer apply the case-of-join-point-transformation universally. This transformation would do:--  case (join go @a n f x = case n of 0 -> x-                                     n -> go @a (n-1) f (f x)-        in go @Bool n neg True) of-    True -> e1; False -> e2-- ===>--  join go @a n f x = case n of 0 -> case x of True -> e1; False -> e2-                          n -> go @a (n-1) f (f x)-  in go @Bool n neg True--but that is ill-typed, as `x` is type `a`, not `Bool`.---This also justifies why we do not consider the `e` in `e |> co` to be in-tail position: A cast changes the type, but the type must be the same. But-operationally, casts are vacuous, so this is a bit unfortunate! See #14610 for-ideas how to fix this.--************************************************************************-*                                                                      *-            In/Out type synonyms-*                                                                      *-********************************************************************* -}--{- Many passes apply a substitution, and it's very handy to have type-   synonyms to remind us whether or not the substitution has been applied -}---- Pre-cloning or substitution-type InBndr     = CoreBndr-type InType     = Type-type InKind     = Kind-type InBind     = CoreBind-type InExpr     = CoreExpr-type InAlt      = CoreAlt-type InArg      = CoreArg-type InCoercion = Coercion---- Post-cloning or substitution-type OutBndr     = CoreBndr-type OutType     = Type-type OutKind     = Kind-type OutCoercion = Coercion-type OutBind     = CoreBind-type OutExpr     = CoreExpr-type OutAlt      = CoreAlt-type OutArg      = CoreArg-type MOutCoercion = MCoercion---{- *********************************************************************-*                                                                      *-              Ticks-*                                                                      *-************************************************************************--}---- | Allows attaching extra information to points in expressions---- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-data Tickish id =-    -- | An @{-# SCC #-}@ profiling annotation, either automatically-    -- added by the desugarer as a result of -auto-all, or added by-    -- the user.-    ProfNote {-      profNoteCC    :: CostCentre, -- ^ the cost centre-      profNoteCount :: !Bool,      -- ^ bump the entry count?-      profNoteScope :: !Bool       -- ^ scopes over the enclosed expression-                                   -- (i.e. not just a tick)-    }--  -- | A "tick" used by HPC to track the execution of each-  -- subexpression in the original source code.-  | HpcTick {-      tickModule :: Module,-      tickId     :: !Int-    }--  -- | A breakpoint for the GHCi debugger.  This behaves like an HPC-  -- tick, but has a list of free variables which will be available-  -- for inspection in GHCi when the program stops at the breakpoint.-  ---  -- NB. we must take account of these Ids when (a) counting free variables,-  -- and (b) substituting (don't substitute for them)-  | Breakpoint-    { breakpointId     :: !Int-    , breakpointFVs    :: [id]  -- ^ the order of this list is important:-                                -- it matches the order of the lists in the-                                -- appropriate entry in HscTypes.ModBreaks.-                                ---                                -- Careful about substitution!  See-                                -- Note [substTickish] in CoreSubst.-    }--  -- | A source note.-  ---  -- Source notes are pure annotations: Their presence should neither-  -- influence compilation nor execution. The semantics are given by-  -- causality: The presence of a source note means that a local-  -- change in the referenced source code span will possibly provoke-  -- the generated code to change. On the flip-side, the functionality-  -- of annotated code *must* be invariant against changes to all-  -- source code *except* the spans referenced in the source notes-  -- (see "Causality of optimized Haskell" paper for details).-  ---  -- Therefore extending the scope of any given source note is always-  -- valid. Note that it is still undesirable though, as this reduces-  -- their usefulness for debugging and profiling. Therefore we will-  -- generally try only to make use of this property where it is-  -- necessary to enable optimizations.-  | SourceNote-    { sourceSpan :: RealSrcSpan -- ^ Source covered-    , sourceName :: String      -- ^ Name for source location-                                --   (uses same names as CCs)-    }--  deriving (Eq, Ord, Data)---- | A "counting tick" (where tickishCounts is True) is one that--- counts evaluations in some way.  We cannot discard a counting tick,--- and the compiler should preserve the number of counting ticks as--- far as possible.------ However, we still allow the simplifier to increase or decrease--- sharing, so in practice the actual number of ticks may vary, except--- that we never change the value from zero to non-zero or vice versa.-tickishCounts :: Tickish id -> Bool-tickishCounts n@ProfNote{} = profNoteCount n-tickishCounts HpcTick{}    = True-tickishCounts Breakpoint{} = True-tickishCounts _            = False----- | Specifies the scoping behaviour of ticks. This governs the--- behaviour of ticks that care about the covered code and the cost--- associated with it. Important for ticks relating to profiling.-data TickishScoping =-    -- | No scoping: The tick does not care about what code it-    -- covers. Transformations can freely move code inside as well as-    -- outside without any additional annotation obligations-    NoScope--    -- | Soft scoping: We want all code that is covered to stay-    -- covered.  Note that this scope type does not forbid-    -- transformations from happening, as long as all results of-    -- the transformations are still covered by this tick or a copy of-    -- it. For example-    ---    --   let x = tick<...> (let y = foo in bar) in baz-    --     ===>-    --   let x = tick<...> bar; y = tick<...> foo in baz-    ---    -- Is a valid transformation as far as "bar" and "foo" is-    -- concerned, because both still are scoped over by the tick.-    ---    -- Note though that one might object to the "let" not being-    -- covered by the tick any more. However, we are generally lax-    -- with this - constant costs don't matter too much, and given-    -- that the "let" was effectively merged we can view it as having-    -- lost its identity anyway.-    ---    -- Also note that this scoping behaviour allows floating a tick-    -- "upwards" in pretty much any situation. For example:-    ---    --   case foo of x -> tick<...> bar-    --     ==>-    --   tick<...> case foo of x -> bar-    ---    -- While this is always legal, we want to make a best effort to-    -- only make us of this where it exposes transformation-    -- opportunities.-  | SoftScope--    -- | Cost centre scoping: We don't want any costs to move to other-    -- cost-centre stacks. This means we not only want no code or cost-    -- to get moved out of their cost centres, but we also object to-    -- code getting associated with new cost-centre ticks - or-    -- changing the order in which they get applied.-    ---    -- A rule of thumb is that we don't want any code to gain new-    -- annotations. However, there are notable exceptions, for-    -- example:-    ---    --   let f = \y -> foo in tick<...> ... (f x) ...-    --     ==>-    --   tick<...> ... foo[x/y] ...-    ---    -- In-lining lambdas like this is always legal, because inlining a-    -- function does not change the cost-centre stack when the-    -- function is called.-  | CostCentreScope--  deriving (Eq)---- | Returns the intended scoping rule for a Tickish-tickishScoped :: Tickish id -> TickishScoping-tickishScoped n@ProfNote{}-  | profNoteScope n        = CostCentreScope-  | otherwise              = NoScope-tickishScoped HpcTick{}    = NoScope-tickishScoped Breakpoint{} = CostCentreScope-   -- Breakpoints are scoped: eventually we're going to do call-   -- stacks, but also this helps prevent the simplifier from moving-   -- breakpoints around and changing their result type (see #1531).-tickishScoped SourceNote{} = SoftScope---- | Returns whether the tick scoping rule is at least as permissive--- as the given scoping rule.-tickishScopesLike :: Tickish id -> TickishScoping -> Bool-tickishScopesLike t scope = tickishScoped t `like` scope-  where NoScope         `like` _               = True-        _               `like` NoScope         = False-        SoftScope       `like` _               = True-        _               `like` SoftScope       = False-        CostCentreScope `like` _               = True---- | Returns @True@ for ticks that can be floated upwards easily even--- where it might change execution counts, such as:------   Just (tick<...> foo)---     ==>---   tick<...> (Just foo)------ This is a combination of @tickishSoftScope@ and--- @tickishCounts@. Note that in principle splittable ticks can become--- floatable using @mkNoTick@ -- even though there's currently no--- tickish for which that is the case.-tickishFloatable :: Tickish id -> Bool-tickishFloatable t = t `tickishScopesLike` SoftScope && not (tickishCounts t)---- | Returns @True@ for a tick that is both counting /and/ scoping and--- can be split into its (tick, scope) parts using 'mkNoScope' and--- 'mkNoTick' respectively.-tickishCanSplit :: Tickish id -> Bool-tickishCanSplit ProfNote{profNoteScope = True, profNoteCount = True}-                   = True-tickishCanSplit _  = False--mkNoCount :: Tickish id -> Tickish id-mkNoCount n | not (tickishCounts n)   = n-            | not (tickishCanSplit n) = panic "mkNoCount: Cannot split!"-mkNoCount n@ProfNote{}                = n {profNoteCount = False}-mkNoCount _                           = panic "mkNoCount: Undefined split!"--mkNoScope :: Tickish id -> Tickish id-mkNoScope n | tickishScoped n == NoScope  = n-            | not (tickishCanSplit n)     = panic "mkNoScope: Cannot split!"-mkNoScope n@ProfNote{}                    = n {profNoteScope = False}-mkNoScope _                               = panic "mkNoScope: Undefined split!"---- | Return @True@ if this source annotation compiles to some backend--- code. Without this flag, the tickish is seen as a simple annotation--- that does not have any associated evaluation code.------ What this means that we are allowed to disregard the tick if doing--- so means that we can skip generating any code in the first place. A--- typical example is top-level bindings:------   foo = tick<...> \y -> ...---     ==>---   foo = \y -> tick<...> ...------ Here there is just no operational difference between the first and--- the second version. Therefore code generation should simply--- translate the code as if it found the latter.-tickishIsCode :: Tickish id -> Bool-tickishIsCode SourceNote{} = False-tickishIsCode _tickish     = True  -- all the rest for now----- | Governs the kind of expression that the tick gets placed on when--- annotating for example using @mkTick@. If we find that we want to--- put a tickish on an expression ruled out here, we try to float it--- inwards until we find a suitable expression.-data TickishPlacement =--    -- | Place ticks exactly on run-time expressions. We can still-    -- move the tick through pure compile-time constructs such as-    -- other ticks, casts or type lambdas. This is the most-    -- restrictive placement rule for ticks, as all tickishs have in-    -- common that they want to track runtime processes. The only-    -- legal placement rule for counting ticks.-    PlaceRuntime--    -- | As @PlaceRuntime@, but we float the tick through all-    -- lambdas. This makes sense where there is little difference-    -- between annotating the lambda and annotating the lambda's code.-  | PlaceNonLam--    -- | In addition to floating through lambdas, cost-centre style-    -- tickishs can also be moved from constructors, non-function-    -- variables and literals. For example:-    ---    --   let x = scc<...> C (scc<...> y) (scc<...> 3) in ...-    ---    -- Neither the constructor application, the variable or the-    -- literal are likely to have any cost worth mentioning. And even-    -- if y names a thunk, the call would not care about the-    -- evaluation context. Therefore removing all annotations in the-    -- above example is safe.-  | PlaceCostCentre--  deriving (Eq)---- | Placement behaviour we want for the ticks-tickishPlace :: Tickish id -> TickishPlacement-tickishPlace n@ProfNote{}-  | profNoteCount n        = PlaceRuntime-  | otherwise              = PlaceCostCentre-tickishPlace HpcTick{}     = PlaceRuntime-tickishPlace Breakpoint{}  = PlaceRuntime-tickishPlace SourceNote{}  = PlaceNonLam---- | Returns whether one tick "contains" the other one, therefore--- making the second tick redundant.-tickishContains :: Eq b => Tickish b -> Tickish b -> Bool-tickishContains (SourceNote sp1 n1) (SourceNote sp2 n2)-  = containsSpan sp1 sp2 && n1 == n2-    -- compare the String last-tickishContains t1 t2-  = t1 == t2--{--************************************************************************-*                                                                      *-                Orphans-*                                                                      *-************************************************************************--}---- | Is this instance an orphan?  If it is not an orphan, contains an 'OccName'--- witnessing the instance's non-orphanhood.--- See Note [Orphans]-data IsOrphan-  = IsOrphan-  | NotOrphan OccName -- The OccName 'n' witnesses the instance's non-orphanhood-                      -- In that case, the instance is fingerprinted as part-                      -- of the definition of 'n's definition-    deriving Data---- | Returns true if 'IsOrphan' is orphan.-isOrphan :: IsOrphan -> Bool-isOrphan IsOrphan = True-isOrphan _ = False---- | Returns true if 'IsOrphan' is not an orphan.-notOrphan :: IsOrphan -> Bool-notOrphan NotOrphan{} = True-notOrphan _ = False--chooseOrphanAnchor :: NameSet -> IsOrphan--- Something (rule, instance) is relate to all the Names in this--- list. Choose one of them to be an "anchor" for the orphan.  We make--- the choice deterministic to avoid gratuitous changes in the ABI--- hash (#4012).  Specifically, use lexicographic comparison of--- OccName rather than comparing Uniques------ NB: 'minimum' use Ord, and (Ord OccName) works lexicographically----chooseOrphanAnchor local_names-  | isEmptyNameSet local_names = IsOrphan-  | otherwise                  = NotOrphan (minimum occs)-  where-    occs = map nameOccName $ nonDetEltsUniqSet local_names-    -- It's OK to use nonDetEltsUFM here, see comments above--instance Binary IsOrphan where-    put_ bh IsOrphan = putByte bh 0-    put_ bh (NotOrphan n) = do-        putByte bh 1-        put_ bh n-    get bh = do-        h <- getByte bh-        case h of-            0 -> return IsOrphan-            _ -> do-                n <- get bh-                return $ NotOrphan n--{--Note [Orphans]-~~~~~~~~~~~~~~-Class instances, rules, and family instances are divided into orphans-and non-orphans.  Roughly speaking, an instance/rule is an orphan if-its left hand side mentions nothing defined in this module.  Orphan-hood-has two major consequences-- * A module that contains orphans is called an "orphan module".  If-   the module being compiled depends (transitively) on an orphan-   module M, then M.hi is read in regardless of whether M is otherwise-   needed. This is to ensure that we don't miss any instance decls in-   M.  But it's painful, because it means we need to keep track of all-   the orphan modules below us.-- * A non-orphan is not finger-printed separately.  Instead, for-   fingerprinting purposes it is treated as part of the entity it-   mentions on the LHS.  For example-      data T = T1 | T2-      instance Eq T where ....-   The instance (Eq T) is incorporated as part of T's fingerprint.--   In contrast, orphans are all fingerprinted together in the-   mi_orph_hash field of the ModIface.--   See GHC.Iface.Utils.addFingerprints.--Orphan-hood is computed-  * For class instances:-      when we make a ClsInst-    (because it is needed during instance lookup)--  * For rules and family instances:-       when we generate an IfaceRule (GHC.Iface.Utils.coreRuleToIfaceRule)-                     or IfaceFamInst (GHC.Iface.Utils.instanceToIfaceInst)--}--{--************************************************************************-*                                                                      *-\subsection{Transformation rules}-*                                                                      *-************************************************************************--The CoreRule type and its friends are dealt with mainly in CoreRules,-but CoreFVs, Subst, PprCore, CoreTidy also inspect the representation.--}---- | Gathers a collection of 'CoreRule's. Maps (the name of) an 'Id' to its rules-type RuleBase = NameEnv [CoreRule]-        -- The rules are unordered;-        -- we sort out any overlaps on lookup---- | A full rule environment which we can apply rules from.  Like a 'RuleBase',--- but it also includes the set of visible orphans we use to filter out orphan--- rules which are not visible (even though we can see them...)-data RuleEnv-    = RuleEnv { re_base          :: RuleBase-              , re_visible_orphs :: ModuleSet-              }--mkRuleEnv :: RuleBase -> [Module] -> RuleEnv-mkRuleEnv rules vis_orphs = RuleEnv rules (mkModuleSet vis_orphs)--emptyRuleEnv :: RuleEnv-emptyRuleEnv = RuleEnv emptyNameEnv emptyModuleSet---- | A 'CoreRule' is:------ * \"Local\" if the function it is a rule for is defined in the---   same module as the rule itself.------ * \"Orphan\" if nothing on the LHS is defined in the same module---   as the rule itself-data CoreRule-  = Rule {-        ru_name :: RuleName,            -- ^ Name of the rule, for communication with the user-        ru_act  :: Activation,          -- ^ When the rule is active--        -- Rough-matching stuff-        -- see comments with InstEnv.ClsInst( is_cls, is_rough )-        ru_fn    :: Name,               -- ^ Name of the 'Id.Id' at the head of this rule-        ru_rough :: [Maybe Name],       -- ^ Name at the head of each argument to the left hand side--        -- Proper-matching stuff-        -- see comments with InstEnv.ClsInst( is_tvs, is_tys )-        ru_bndrs :: [CoreBndr],         -- ^ Variables quantified over-        ru_args  :: [CoreExpr],         -- ^ Left hand side arguments--        -- And the right-hand side-        ru_rhs   :: CoreExpr,           -- ^ Right hand side of the rule-                                        -- Occurrence info is guaranteed correct-                                        -- See Note [OccInfo in unfoldings and rules]--        -- Locality-        ru_auto :: Bool,   -- ^ @True@  <=> this rule is auto-generated-                           --               (notably by Specialise or SpecConstr)-                           --   @False@ <=> generated at the user's behest-                           -- See Note [Trimming auto-rules] in GHC.Iface.Tidy-                           -- for the sole purpose of this field.--        ru_origin :: !Module,   -- ^ 'Module' the rule was defined in, used-                                -- to test if we should see an orphan rule.--        ru_orphan :: !IsOrphan, -- ^ Whether or not the rule is an orphan.--        ru_local :: Bool        -- ^ @True@ iff the fn at the head of the rule is-                                -- defined in the same module as the rule-                                -- and is not an implicit 'Id' (like a record selector,-                                -- class operation, or data constructor).  This-                                -- is different from 'ru_orphan', where a rule-                                -- can avoid being an orphan if *any* Name in-                                -- LHS of the rule was defined in the same-                                -- module as the rule.-    }--  -- | Built-in rules are used for constant folding-  -- and suchlike.  They have no free variables.-  -- A built-in rule is always visible (there is no such thing as-  -- an orphan built-in rule.)-  | BuiltinRule {-        ru_name  :: RuleName,   -- ^ As above-        ru_fn    :: Name,       -- ^ As above-        ru_nargs :: Int,        -- ^ Number of arguments that 'ru_try' consumes,-                                -- if it fires, including type arguments-        ru_try   :: RuleFun-                -- ^ This function does the rewrite.  It given too many-                -- arguments, it simply discards them; the returned 'CoreExpr'-                -- is just the rewrite of 'ru_fn' applied to the first 'ru_nargs' args-    }-                -- See Note [Extra args in rule matching] in Rules.hs--type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr-type InScopeEnv = (InScopeSet, IdUnfoldingFun)--type IdUnfoldingFun = Id -> Unfolding--- A function that embodies how to unfold an Id if you need--- to do that in the Rule.  The reason we need to pass this info in--- is that whether an Id is unfoldable depends on the simplifier phase--isBuiltinRule :: CoreRule -> Bool-isBuiltinRule (BuiltinRule {}) = True-isBuiltinRule _                = False--isAutoRule :: CoreRule -> Bool-isAutoRule (BuiltinRule {}) = False-isAutoRule (Rule { ru_auto = is_auto }) = is_auto---- | The number of arguments the 'ru_fn' must be applied--- to before the rule can match on it-ruleArity :: CoreRule -> Int-ruleArity (BuiltinRule {ru_nargs = n}) = n-ruleArity (Rule {ru_args = args})      = length args--ruleName :: CoreRule -> RuleName-ruleName = ru_name--ruleModule :: CoreRule -> Maybe Module-ruleModule Rule { ru_origin } = Just ru_origin-ruleModule BuiltinRule {} = Nothing--ruleActivation :: CoreRule -> Activation-ruleActivation (BuiltinRule { })       = AlwaysActive-ruleActivation (Rule { ru_act = act }) = act---- | The 'Name' of the 'Id.Id' at the head of the rule left hand side-ruleIdName :: CoreRule -> Name-ruleIdName = ru_fn--isLocalRule :: CoreRule -> Bool-isLocalRule = ru_local---- | Set the 'Name' of the 'Id.Id' at the head of the rule left hand side-setRuleIdName :: Name -> CoreRule -> CoreRule-setRuleIdName nm ru = ru { ru_fn = nm }--{--************************************************************************-*                                                                      *-                Unfoldings-*                                                                      *-************************************************************************--The @Unfolding@ type is declared here to avoid numerous loops--}---- | Records the /unfolding/ of an identifier, which is approximately the form the--- identifier would have if we substituted its definition in for the identifier.--- This type should be treated as abstract everywhere except in "CoreUnfold"-data Unfolding-  = NoUnfolding        -- ^ We have no information about the unfolding.--  | BootUnfolding      -- ^ We have no information about the unfolding, because-                       -- this 'Id' came from an @hi-boot@ file.-                       -- See Note [Inlining and hs-boot files] in GHC.CoreToIface-                       -- for what this is used for.--  | OtherCon [AltCon]  -- ^ It ain't one of these constructors.-                       -- @OtherCon xs@ also indicates that something has been evaluated-                       -- and hence there's no point in re-evaluating it.-                       -- @OtherCon []@ is used even for non-data-type values-                       -- to indicated evaluated-ness.  Notably:-                       ---                       -- > data C = C !(Int -> Int)-                       -- > case x of { C f -> ... }-                       ---                       -- Here, @f@ gets an @OtherCon []@ unfolding.--  | DFunUnfolding {     -- The Unfolding of a DFunId-                        -- See Note [DFun unfoldings]-                        --     df = /\a1..am. \d1..dn. MkD t1 .. tk-                        --                                 (op1 a1..am d1..dn)-                        --                                 (op2 a1..am d1..dn)-        df_bndrs :: [Var],      -- The bound variables [a1..m],[d1..dn]-        df_con   :: DataCon,    -- The dictionary data constructor (never a newtype datacon)-        df_args  :: [CoreExpr]  -- Args of the data con: types, superclasses and methods,-    }                           -- in positional order--  | CoreUnfolding {             -- An unfolding for an Id with no pragma,-                                -- or perhaps a NOINLINE pragma-                                -- (For NOINLINE, the phase, if any, is in the-                                -- InlinePragInfo for this Id.)-        uf_tmpl       :: CoreExpr,        -- Template; occurrence info is correct-        uf_src        :: UnfoldingSource, -- Where the unfolding came from-        uf_is_top     :: Bool,          -- True <=> top level binding-        uf_is_value   :: Bool,          -- exprIsHNF template (cached); it is ok to discard-                                        --      a `seq` on this variable-        uf_is_conlike :: Bool,          -- True <=> applicn of constructor or CONLIKE function-                                        --      Cached version of exprIsConLike-        uf_is_work_free :: Bool,                -- True <=> doesn't waste (much) work to expand-                                        --          inside an inlining-                                        --      Cached version of exprIsCheap-        uf_expandable :: Bool,          -- True <=> can expand in RULE matching-                                        --      Cached version of exprIsExpandable-        uf_guidance   :: UnfoldingGuidance      -- Tells about the *size* of the template.-    }-  -- ^ An unfolding with redundant cached information. Parameters:-  ---  --  uf_tmpl: Template used to perform unfolding;-  --           NB: Occurrence info is guaranteed correct:-  --               see Note [OccInfo in unfoldings and rules]-  ---  --  uf_is_top: Is this a top level binding?-  ---  --  uf_is_value: 'exprIsHNF' template (cached); it is ok to discard a 'seq' on-  --     this variable-  ---  --  uf_is_work_free:  Does this waste only a little work if we expand it inside an inlining?-  --     Basically this is a cached version of 'exprIsWorkFree'-  ---  --  uf_guidance:  Tells us about the /size/ of the unfolding template----------------------------------------------------data UnfoldingSource-  = -- See also Note [Historical note: unfoldings for wrappers]--    InlineRhs          -- The current rhs of the function-                       -- Replace uf_tmpl each time around--  | InlineStable       -- From an INLINE or INLINABLE pragma-                       --   INLINE     if guidance is UnfWhen-                       --   INLINABLE  if guidance is UnfIfGoodArgs/UnfoldNever-                       -- (well, technically an INLINABLE might be made-                       -- UnfWhen if it was small enough, and then-                       -- it will behave like INLINE outside the current-                       -- module, but that is the way automatic unfoldings-                       -- work so it is consistent with the intended-                       -- meaning of INLINABLE).-                       ---                       -- uf_tmpl may change, but only as a result of-                       -- gentle simplification, it doesn't get updated-                       -- to the current RHS during compilation as with-                       -- InlineRhs.-                       ---                       -- See Note [InlineStable]--  | InlineCompulsory   -- Something that *has* no binding, so you *must* inline it-                       -- Only a few primop-like things have this property-                       -- (see MkId.hs, calls to mkCompulsoryUnfolding).-                       -- Inline absolutely always, however boring the context.------ | 'UnfoldingGuidance' says when unfolding should take place-data UnfoldingGuidance-  = UnfWhen {   -- Inline without thinking about the *size* of the uf_tmpl-                -- Used (a) for small *and* cheap unfoldings-                --      (b) for INLINE functions-                -- See Note [INLINE for small functions] in CoreUnfold-      ug_arity    :: Arity,     -- Number of value arguments expected--      ug_unsat_ok  :: Bool,     -- True <=> ok to inline even if unsaturated-      ug_boring_ok :: Bool      -- True <=> ok to inline even if the context is boring-                -- So True,True means "always"-    }--  | UnfIfGoodArgs {     -- Arose from a normal Id; the info here is the-                        -- result of a simple analysis of the RHS--      ug_args ::  [Int],  -- Discount if the argument is evaluated.-                          -- (i.e., a simplification will definitely-                          -- be possible).  One elt of the list per *value* arg.--      ug_size :: Int,     -- The "size" of the unfolding.--      ug_res :: Int       -- Scrutinee discount: the discount to subtract if the thing is in-    }                     -- a context (case (thing args) of ...),-                          -- (where there are the right number of arguments.)--  | UnfNever        -- The RHS is big, so don't inline it-  deriving (Eq)--{--Note [Historical note: unfoldings for wrappers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We used to have a nice clever scheme in interface files for-wrappers. A wrapper's unfolding can be reconstructed from its worker's-id and its strictness. This decreased .hi file size (sometimes-significantly, for modules like GHC.Classes with many high-arity w/w-splits) and had a slight corresponding effect on compile times.--However, when we added the second demand analysis, this scheme lead to-some Core lint errors. The second analysis could change the strictness-signatures, which sometimes resulted in a wrapper's regenerated-unfolding applying the wrapper to too many arguments.--Instead of repairing the clever .hi scheme, we abandoned it in favor-of simplicity. The .hi sizes are usually insignificant (excluding the-+1M for base libraries), and compile time barely increases (~+1% for-nofib). The nicer upshot is that the UnfoldingSource no longer mentions-an Id, so, eg, substitutions need not traverse them.---Note [DFun unfoldings]-~~~~~~~~~~~~~~~~~~~~~~-The Arity in a DFunUnfolding is total number of args (type and value)-that the DFun needs to produce a dictionary.  That's not necessarily-related to the ordinary arity of the dfun Id, esp if the class has-one method, so the dictionary is represented by a newtype.  Example--     class C a where { op :: a -> Int }-     instance C a -> C [a] where op xs = op (head xs)--The instance translates to--     $dfCList :: forall a. C a => C [a]  -- Arity 2!-     $dfCList = /\a.\d. $copList {a} d |> co--     $copList :: forall a. C a => [a] -> Int  -- Arity 2!-     $copList = /\a.\d.\xs. op {a} d (head xs)--Now we might encounter (op (dfCList {ty} d) a1 a2)-and we want the (op (dfList {ty} d)) rule to fire, because $dfCList-has all its arguments, even though its (value) arity is 2.  That's-why we record the number of expected arguments in the DFunUnfolding.--Note that although it's an Arity, it's most convenient for it to give-the *total* number of arguments, both type and value.  See the use-site in exprIsConApp_maybe.--}---- Constants for the UnfWhen constructor-needSaturated, unSaturatedOk :: Bool-needSaturated = False-unSaturatedOk = True--boringCxtNotOk, boringCxtOk :: Bool-boringCxtOk    = True-boringCxtNotOk = False---------------------------------------------------noUnfolding :: Unfolding--- ^ There is no known 'Unfolding'-evaldUnfolding :: Unfolding--- ^ This unfolding marks the associated thing as being evaluated--noUnfolding    = NoUnfolding-evaldUnfolding = OtherCon []---- | There is no known 'Unfolding', because this came from an--- hi-boot file.-bootUnfolding :: Unfolding-bootUnfolding = BootUnfolding--mkOtherCon :: [AltCon] -> Unfolding-mkOtherCon = OtherCon--isStableSource :: UnfoldingSource -> Bool--- Keep the unfolding template-isStableSource InlineCompulsory   = True-isStableSource InlineStable       = True-isStableSource InlineRhs          = False---- | Retrieves the template of an unfolding: panics if none is known-unfoldingTemplate :: Unfolding -> CoreExpr-unfoldingTemplate = uf_tmpl---- | Retrieves the template of an unfolding if possible--- maybeUnfoldingTemplate is used mainly wnen specialising, and we do--- want to specialise DFuns, so it's important to return a template--- for DFunUnfoldings-maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr-maybeUnfoldingTemplate (CoreUnfolding { uf_tmpl = expr })-  = Just expr-maybeUnfoldingTemplate (DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = args })-  = Just (mkLams bndrs (mkApps (Var (dataConWorkId con)) args))-maybeUnfoldingTemplate _-  = Nothing---- | The constructors that the unfolding could never be:--- returns @[]@ if no information is available-otherCons :: Unfolding -> [AltCon]-otherCons (OtherCon cons) = cons-otherCons _               = []---- | Determines if it is certainly the case that the unfolding will--- yield a value (something in HNF): returns @False@ if unsure-isValueUnfolding :: Unfolding -> Bool-        -- Returns False for OtherCon-isValueUnfolding (CoreUnfolding { uf_is_value = is_evald }) = is_evald-isValueUnfolding _                                          = False---- | Determines if it possibly the case that the unfolding will--- yield a value. Unlike 'isValueUnfolding' it returns @True@--- for 'OtherCon'-isEvaldUnfolding :: Unfolding -> Bool-        -- Returns True for OtherCon-isEvaldUnfolding (OtherCon _)                               = True-isEvaldUnfolding (CoreUnfolding { uf_is_value = is_evald }) = is_evald-isEvaldUnfolding _                                          = False---- | @True@ if the unfolding is a constructor application, the application--- of a CONLIKE function or 'OtherCon'-isConLikeUnfolding :: Unfolding -> Bool-isConLikeUnfolding (OtherCon _)                             = True-isConLikeUnfolding (CoreUnfolding { uf_is_conlike = con })  = con-isConLikeUnfolding _                                        = False---- | Is the thing we will unfold into certainly cheap?-isCheapUnfolding :: Unfolding -> Bool-isCheapUnfolding (CoreUnfolding { uf_is_work_free = is_wf }) = is_wf-isCheapUnfolding _                                           = False--isExpandableUnfolding :: Unfolding -> Bool-isExpandableUnfolding (CoreUnfolding { uf_expandable = is_expable }) = is_expable-isExpandableUnfolding _                                              = False--expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr--- Expand an expandable unfolding; this is used in rule matching---   See Note [Expanding variables] in Rules.hs--- The key point here is that CONLIKE things can be expanded-expandUnfolding_maybe (CoreUnfolding { uf_expandable = True, uf_tmpl = rhs }) = Just rhs-expandUnfolding_maybe _                                                       = Nothing--isCompulsoryUnfolding :: Unfolding -> Bool-isCompulsoryUnfolding (CoreUnfolding { uf_src = InlineCompulsory }) = True-isCompulsoryUnfolding _                                             = False--isStableUnfolding :: Unfolding -> Bool--- True of unfoldings that should not be overwritten--- by a CoreUnfolding for the RHS of a let-binding-isStableUnfolding (CoreUnfolding { uf_src = src }) = isStableSource src-isStableUnfolding (DFunUnfolding {})               = True-isStableUnfolding _                                = False---- | Only returns False if there is no unfolding information available at all-hasSomeUnfolding :: Unfolding -> Bool-hasSomeUnfolding NoUnfolding   = False-hasSomeUnfolding BootUnfolding = False-hasSomeUnfolding _             = True--isBootUnfolding :: Unfolding -> Bool-isBootUnfolding BootUnfolding = True-isBootUnfolding _             = False--neverUnfoldGuidance :: UnfoldingGuidance -> Bool-neverUnfoldGuidance UnfNever = True-neverUnfoldGuidance _        = False--isFragileUnfolding :: Unfolding -> Bool--- An unfolding is fragile if it mentions free variables or--- is otherwise subject to change.  A robust one can be kept.--- See Note [Fragile unfoldings]-isFragileUnfolding (CoreUnfolding {}) = True-isFragileUnfolding (DFunUnfolding {}) = True-isFragileUnfolding _                  = False-  -- NoUnfolding, BootUnfolding, OtherCon are all non-fragile--canUnfold :: Unfolding -> Bool-canUnfold (CoreUnfolding { uf_guidance = g }) = not (neverUnfoldGuidance g)-canUnfold _                                   = False--{- Note [Fragile unfoldings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-An unfolding is "fragile" if it mentions free variables (and hence would-need substitution) or might be affected by optimisation.  The non-fragile-ones are--   NoUnfolding, BootUnfolding--   OtherCon {}    If we know this binder (say a lambda binder) will be-                  bound to an evaluated thing, we want to retain that-                  info in simpleOptExpr; see #13077.--We consider even a StableUnfolding as fragile, because it needs substitution.--Note [InlineStable]-~~~~~~~~~~~~~~~~~-When you say-      {-# INLINE f #-}-      f x = <rhs>-you intend that calls (f e) are replaced by <rhs>[e/x] So we-should capture (\x.<rhs>) in the Unfolding of 'f', and never meddle-with it.  Meanwhile, we can optimise <rhs> to our heart's content,-leaving the original unfolding intact in Unfolding of 'f'. For example-        all xs = foldr (&&) True xs-        any p = all . map p  {-# INLINE any #-}-We optimise any's RHS fully, but leave the InlineRule saying "all . map p",-which deforests well at the call site.--So INLINE pragma gives rise to an InlineRule, which captures the original RHS.--Moreover, it's only used when 'f' is applied to the-specified number of arguments; that is, the number of argument on-the LHS of the '=' sign in the original source definition.-For example, (.) is now defined in the libraries like this-   {-# INLINE (.) #-}-   (.) f g = \x -> f (g x)-so that it'll inline when applied to two arguments. If 'x' appeared-on the left, thus-   (.) f g x = f (g x)-it'd only inline when applied to three arguments.  This slightly-experimental-change was requested by Roman, but it seems to make sense.--See also Note [Inlining an InlineRule] in CoreUnfold.---Note [OccInfo in unfoldings and rules]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In unfoldings and rules, we guarantee that the template is occ-analysed,-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 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---************************************************************************-*                                                                      *-                  AltCon-*                                                                      *-************************************************************************--}---- The Ord is needed for the FiniteMap used in the lookForConstructor--- in SimplEnv.  If you declared that lookForConstructor *ignores*--- constructor-applications with LitArg args, then you could get--- rid of this Ord.--instance Outputable AltCon where-  ppr (DataAlt dc) = ppr dc-  ppr (LitAlt lit) = ppr lit-  ppr DEFAULT      = text "__DEFAULT"--cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering-cmpAlt (con1, _, _) (con2, _, _) = con1 `cmpAltCon` con2--ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool-ltAlt a1 a2 = (a1 `cmpAlt` a2) == LT--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: see Note [Case expression invariants]-cmpAltCon DEFAULT      DEFAULT     = EQ-cmpAltCon DEFAULT      _           = LT--cmpAltCon (DataAlt d1) (DataAlt d2) = dataConTag d1 `compare` dataConTag d2-cmpAltCon (DataAlt _)  DEFAULT      = GT-cmpAltCon (LitAlt  l1) (LitAlt  l2) = l1 `compare` l2-cmpAltCon (LitAlt _)   DEFAULT      = GT--cmpAltCon con1 con2 = WARN( True, text "Comparing incomparable AltCons" <+>-                                  ppr con1 <+> ppr con2 )-                      LT--{--************************************************************************-*                                                                      *-\subsection{Useful synonyms}-*                                                                      *-************************************************************************--Note [CoreProgram]-~~~~~~~~~~~~~~~~~~-The top level bindings of a program, a CoreProgram, are represented as-a list of CoreBind-- * Later bindings in the list can refer to earlier ones, but not vice-   versa.  So this is OK-      NonRec { x = 4 }-      Rec { p = ...q...x...-          ; q = ...p...x }-      Rec { f = ...p..x..f.. }-      NonRec { g = ..f..q...x.. }-   But it would NOT be ok for 'f' to refer to 'g'.-- * The occurrence analyser does strongly-connected component analysis-   on each Rec binding, and splits it into a sequence of smaller-   bindings where possible.  So the program typically starts life as a-   single giant Rec, which is then dependency-analysed into smaller-   chunks.--}---- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-type CoreProgram = [CoreBind]   -- See Note [CoreProgram]---- | The common case for the type of binders and variables when--- we are manipulating the Core language within GHC-type CoreBndr = Var--- | Expressions where binders are 'CoreBndr's-type CoreExpr = Expr CoreBndr--- | Argument expressions where binders are 'CoreBndr's-type CoreArg  = Arg  CoreBndr--- | Binding groups where binders are 'CoreBndr's-type CoreBind = Bind CoreBndr--- | Case alternatives where binders are 'CoreBndr's-type CoreAlt  = Alt  CoreBndr--{--************************************************************************-*                                                                      *-\subsection{Tagging}-*                                                                      *-************************************************************************--}---- | Binders are /tagged/ with a t-data TaggedBndr t = TB CoreBndr t       -- TB for "tagged binder"--type TaggedBind t = Bind (TaggedBndr t)-type TaggedExpr t = Expr (TaggedBndr t)-type TaggedArg  t = Arg  (TaggedBndr t)-type TaggedAlt  t = Alt  (TaggedBndr t)--instance Outputable b => Outputable (TaggedBndr b) where-  ppr (TB b l) = char '<' <> ppr b <> comma <> ppr l <> char '>'--deTagExpr :: TaggedExpr t -> CoreExpr-deTagExpr (Var v)                   = Var v-deTagExpr (Lit l)                   = Lit l-deTagExpr (Type ty)                 = Type ty-deTagExpr (Coercion co)             = Coercion co-deTagExpr (App e1 e2)               = App (deTagExpr e1) (deTagExpr e2)-deTagExpr (Lam (TB b _) e)          = Lam b (deTagExpr e)-deTagExpr (Let bind body)           = Let (deTagBind bind) (deTagExpr body)-deTagExpr (Case e (TB b _) ty alts) = Case (deTagExpr e) b ty (map deTagAlt alts)-deTagExpr (Tick t e)                = Tick t (deTagExpr e)-deTagExpr (Cast e co)               = Cast (deTagExpr e) co--deTagBind :: TaggedBind t -> CoreBind-deTagBind (NonRec (TB b _) rhs) = NonRec b (deTagExpr rhs)-deTagBind (Rec prs)             = Rec [(b, deTagExpr rhs) | (TB b _, rhs) <- prs]--deTagAlt :: TaggedAlt t -> CoreAlt-deTagAlt (con, bndrs, rhs) = (con, [b | TB b _ <- bndrs], deTagExpr rhs)--{--************************************************************************-*                                                                      *-\subsection{Core-constructing functions with checking}-*                                                                      *-************************************************************************--}---- | Apply a list of argument expressions to a function expression in a nested fashion. Prefer to--- use 'MkCore.mkCoreApps' if possible-mkApps    :: Expr b -> [Arg b]  -> Expr b--- | Apply a list of type argument expressions to a function expression in a nested fashion-mkTyApps  :: Expr b -> [Type]   -> Expr b--- | Apply a list of coercion argument expressions to a function expression in a nested fashion-mkCoApps  :: Expr b -> [Coercion] -> Expr b--- | Apply a list of type or value variables to a function expression in a nested fashion-mkVarApps :: Expr b -> [Var] -> Expr b--- | Apply a list of argument expressions to a data constructor in a nested fashion. Prefer to--- use 'MkCore.mkCoreConApps' if possible-mkConApp      :: DataCon -> [Arg b] -> Expr b--mkApps    f args = foldl' App                       f args-mkCoApps  f args = foldl' (\ e a -> App e (Coercion a)) f args-mkVarApps f vars = foldl' (\ e a -> App e (varToCoreExpr a)) f vars-mkConApp con args = mkApps (Var (dataConWorkId con)) args--mkTyApps  f args = foldl' (\ e a -> App e (mkTyArg a)) f args--mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b-mkConApp2 con tys arg_ids = Var (dataConWorkId con)-                            `mkApps` map Type tys-                            `mkApps` map varToCoreExpr arg_ids--mkTyArg :: Type -> Expr b-mkTyArg ty-  | Just co <- isCoercionTy_maybe ty = Coercion co-  | otherwise                        = Type ty---- | Create a machine integer literal expression of type @Int#@ from an @Integer@.--- If you want an expression of type @Int@ use 'MkCore.mkIntExpr'-mkIntLit      :: DynFlags -> Integer -> Expr b--- | Create a machine integer literal expression of type @Int#@ from an @Int@.--- If you want an expression of type @Int@ use 'MkCore.mkIntExpr'-mkIntLitInt   :: DynFlags -> Int     -> Expr b--mkIntLit    dflags n = Lit (mkLitInt dflags n)-mkIntLitInt dflags n = Lit (mkLitInt dflags (toInteger n))---- | Create a machine word literal expression of type  @Word#@ from an @Integer@.--- If you want an expression of type @Word@ use 'MkCore.mkWordExpr'-mkWordLit     :: DynFlags -> Integer -> Expr b--- | Create a machine word literal expression of type  @Word#@ from a @Word@.--- If you want an expression of type @Word@ use 'MkCore.mkWordExpr'-mkWordLitWord :: DynFlags -> Word -> Expr b--mkWordLit     dflags w = Lit (mkLitWord dflags w)-mkWordLitWord dflags w = Lit (mkLitWord dflags (toInteger w))--mkWord64LitWord64 :: Word64 -> Expr b-mkWord64LitWord64 w = Lit (mkLitWord64 (toInteger w))--mkInt64LitInt64 :: Int64 -> Expr b-mkInt64LitInt64 w = Lit (mkLitInt64 (toInteger w))---- | Create a machine character literal expression of type @Char#@.--- If you want an expression of type @Char@ use 'MkCore.mkCharExpr'-mkCharLit :: Char -> Expr b--- | Create a machine string literal expression of type @Addr#@.--- If you want an expression of type @String@ use 'MkCore.mkStringExpr'-mkStringLit :: String -> Expr b--mkCharLit   c = Lit (mkLitChar c)-mkStringLit s = Lit (mkLitString s)---- | Create a machine single precision literal expression of type @Float#@ from a @Rational@.--- If you want an expression of type @Float@ use 'MkCore.mkFloatExpr'-mkFloatLit :: Rational -> Expr b--- | Create a machine single precision literal expression of type @Float#@ from a @Float@.--- If you want an expression of type @Float@ use 'MkCore.mkFloatExpr'-mkFloatLitFloat :: Float -> Expr b--mkFloatLit      f = Lit (mkLitFloat f)-mkFloatLitFloat f = Lit (mkLitFloat (toRational f))---- | Create a machine double precision literal expression of type @Double#@ from a @Rational@.--- If you want an expression of type @Double@ use 'MkCore.mkDoubleExpr'-mkDoubleLit :: Rational -> Expr b--- | Create a machine double precision literal expression of type @Double#@ from a @Double@.--- If you want an expression of type @Double@ use 'MkCore.mkDoubleExpr'-mkDoubleLitDouble :: Double -> Expr b--mkDoubleLit       d = Lit (mkLitDouble d)-mkDoubleLitDouble d = Lit (mkLitDouble (toRational d))---- | Bind all supplied binding groups over an expression in a nested let expression. Assumes--- that the rhs satisfies the let/app invariant.  Prefer to use 'MkCore.mkCoreLets' if--- possible, which does guarantee the invariant-mkLets        :: [Bind b] -> Expr b -> Expr b--- | Bind all supplied binders over an expression in a nested lambda expression. Prefer to--- use 'MkCore.mkCoreLams' if possible-mkLams        :: [b] -> Expr b -> Expr b--mkLams binders body = foldr Lam body binders-mkLets binds body   = foldr mkLet body binds--mkLet :: Bind b -> Expr b -> Expr b--- The desugarer sometimes generates an empty Rec group--- which Lint rejects, so we kill it off right away-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-mkTyBind tv ty      = NonRec tv (Type ty)---- | 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-mkCoBind :: CoVar -> Coercion -> CoreBind-mkCoBind cv co      = NonRec cv (Coercion co)---- | Convert a binder into either a 'Var' or 'Type' 'Expr' appropriately-varToCoreExpr :: CoreBndr -> Expr b-varToCoreExpr v | isTyVar v = Type (mkTyVarTy v)-                | isCoVar v = Coercion (mkCoVarCo v)-                | otherwise = ASSERT( isId v ) Var v--varsToCoreExprs :: [CoreBndr] -> [Expr b]-varsToCoreExprs vs = map varToCoreExpr vs--{--************************************************************************-*                                                                      *-   Getting a result type-*                                                                      *-************************************************************************--These are defined here to avoid a module loop between CoreUtils and CoreFVs---}--applyTypeToArg :: Type -> CoreExpr -> Type--- ^ Determines the type resulting from applying an expression with given type--- to a given argument expression-applyTypeToArg fun_ty arg = piResultTy fun_ty (exprToType arg)---- | If the expression is a 'Type', converts. Otherwise,--- panics. NB: This does /not/ convert 'Coercion' to 'CoercionTy'.-exprToType :: CoreExpr -> Type-exprToType (Type ty)     = ty-exprToType _bad          = pprPanic "exprToType" empty---- | If the expression is a 'Coercion', converts.-exprToCoercion_maybe :: CoreExpr -> Maybe Coercion-exprToCoercion_maybe (Coercion co) = Just co-exprToCoercion_maybe _             = Nothing--{--************************************************************************-*                                                                      *-\subsection{Simple access functions}-*                                                                      *-************************************************************************--}---- | Extract every variable by this group-bindersOf  :: Bind b -> [b]--- If you edit this function, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs-bindersOf (NonRec binder _) = [binder]-bindersOf (Rec pairs)       = [binder | (binder, _) <- pairs]---- | 'bindersOf' applied to a list of binding groups-bindersOfBinds :: [Bind b] -> [b]-bindersOfBinds binds = foldr ((++) . bindersOf) [] binds--rhssOfBind :: Bind b -> [Expr b]-rhssOfBind (NonRec _ rhs) = [rhs]-rhssOfBind (Rec pairs)    = [rhs | (_,rhs) <- pairs]--rhssOfAlts :: [Alt b] -> [Expr b]-rhssOfAlts alts = [e | (_,_,e) <- alts]---- | Collapse all the bindings in the supplied groups into a single--- list of lhs\/rhs pairs suitable for binding in a 'Rec' binding group-flattenBinds :: [Bind b] -> [(b, Expr b)]-flattenBinds (NonRec b r : binds) = (b,r) : flattenBinds binds-flattenBinds (Rec prs1   : binds) = prs1 ++ flattenBinds binds-flattenBinds []                   = []---- | We often want to strip off leading lambdas before getting down to--- business. Variants are 'collectTyBinders', 'collectValBinders',--- and 'collectTyAndValBinders'-collectBinders         :: Expr b   -> ([b],     Expr b)-collectTyBinders       :: CoreExpr -> ([TyVar], CoreExpr)-collectValBinders      :: CoreExpr -> ([Id],    CoreExpr)-collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)--- | Strip off exactly N leading lambdas (type or value). Good for use with--- join points.-collectNBinders        :: Int -> Expr b -> ([b], Expr b)--collectBinders expr-  = go [] expr-  where-    go bs (Lam b e) = go (b:bs) e-    go bs e          = (reverse bs, e)--collectTyBinders expr-  = go [] expr-  where-    go tvs (Lam b e) | isTyVar b = go (b:tvs) e-    go tvs e                     = (reverse tvs, e)--collectValBinders expr-  = go [] expr-  where-    go ids (Lam b e) | isId b = go (b:ids) e-    go ids body               = (reverse ids, body)--collectTyAndValBinders expr-  = (tvs, ids, body)-  where-    (tvs, body1) = collectTyBinders expr-    (ids, body)  = collectValBinders body1--collectNBinders orig_n orig_expr-  = go orig_n [] orig_expr-  where-    go 0 bs expr      = (reverse bs, expr)-    go n bs (Lam b e) = go (n-1) (b:bs) e-    go _ _  _         = pprPanic "collectNBinders" $ int orig_n---- | Takes a nested application expression and returns the function--- being applied and the arguments to which it is applied-collectArgs :: Expr b -> (Expr b, [Arg b])-collectArgs expr-  = go expr []-  where-    go (App f a) as = go f (a:as)-    go e         as = (e, as)---- | Attempt to remove the last N arguments of a function call.--- Strip off any ticks or coercions encountered along the way and any--- at the end.-stripNArgs :: Word -> Expr a -> Maybe (Expr a)-stripNArgs !n (Tick _ e) = stripNArgs n e-stripNArgs n (Cast f _) = stripNArgs n f-stripNArgs 0 e = Just e-stripNArgs n (App f _) = stripNArgs (n - 1) f-stripNArgs _ _ = Nothing---- | Like @collectArgs@, but also collects looks through floatable--- ticks if it means that we can find more arguments.-collectArgsTicks :: (Tickish Id -> Bool) -> Expr b-                 -> (Expr b, [Arg b], [Tickish Id])-collectArgsTicks skipTick expr-  = go expr [] []-  where-    go (App f a)  as ts = go f (a:as) ts-    go (Tick t e) as ts-      | skipTick t      = go e as (t:ts)-    go e          as ts = (e, as, reverse ts)---{--************************************************************************-*                                                                      *-\subsection{Predicates}-*                                                                      *-************************************************************************--At one time we optionally carried type arguments through to runtime.-@isRuntimeVar v@ returns if (Lam v _) really becomes a lambda at runtime,-i.e. if type applications are actual lambdas because types are kept around-at runtime.  Similarly isRuntimeArg.--}---- | Will this variable exist at runtime?-isRuntimeVar :: Var -> Bool-isRuntimeVar = isId---- | Will this argument expression exist at runtime?-isRuntimeArg :: CoreExpr -> Bool-isRuntimeArg = isValArg---- | Returns @True@ for value arguments, false for type args--- NB: coercions are value arguments (zero width, to be sure,--- like State#, but still value args).-isValArg :: Expr b -> Bool-isValArg e = not (isTypeArg e)---- | Returns @True@ iff the expression is a 'Type' or 'Coercion'--- expression at its top level-isTyCoArg :: Expr b -> Bool-isTyCoArg (Type {})     = True-isTyCoArg (Coercion {}) = True-isTyCoArg _             = False---- | Returns @True@ iff the expression is a 'Coercion'--- expression at its top level-isCoArg :: Expr b -> Bool-isCoArg (Coercion {}) = True-isCoArg _             = False---- | Returns @True@ iff the expression is a 'Type' expression at its--- top level.  Note this does NOT include 'Coercion's.-isTypeArg :: Expr b -> Bool-isTypeArg (Type {}) = True-isTypeArg _         = False---- | The number of binders that bind values rather than types-valBndrCount :: [CoreBndr] -> Int-valBndrCount = count isId---- | The number of argument expressions that are values rather than types at their top level-valArgCount :: [Arg b] -> Int-valArgCount = count isValArg--{--************************************************************************-*                                                                      *-\subsection{Annotated core}-*                                                                      *-************************************************************************--}---- | Annotated core: allows annotation at every node in the tree-type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)---- | A clone of the 'Expr' type but allowing annotation at every tree node-data AnnExpr' bndr annot-  = AnnVar      Id-  | AnnLit      Literal-  | AnnLam      bndr (AnnExpr bndr annot)-  | AnnApp      (AnnExpr bndr annot) (AnnExpr bndr annot)-  | AnnCase     (AnnExpr bndr annot) bndr Type [AnnAlt bndr annot]-  | AnnLet      (AnnBind bndr annot) (AnnExpr bndr annot)-  | AnnCast     (AnnExpr bndr annot) (annot, Coercion)-                   -- Put an annotation on the (root of) the coercion-  | AnnTick     (Tickish Id) (AnnExpr bndr annot)-  | AnnType     Type-  | AnnCoercion Coercion---- | A clone of the 'Alt' type but allowing annotation at every tree node-type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)---- | A clone of the 'Bind' type but allowing annotation at every tree node-data AnnBind bndr annot-  = AnnNonRec bndr (AnnExpr bndr annot)-  | AnnRec    [(bndr, AnnExpr bndr annot)]---- | Takes a nested application expression and returns the function--- being applied and the arguments to which it is applied-collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])-collectAnnArgs expr-  = go expr []-  where-    go (_, AnnApp f a) as = go f (a:as)-    go e               as = (e, as)--collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a-                       -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])-collectAnnArgsTicks tickishOk expr-  = go expr [] []-  where-    go (_, AnnApp f a)  as ts = go f (a:as) ts-    go (_, AnnTick t e) as ts | tickishOk t-                              = go e as (t:ts)-    go e                as ts = (e, as, reverse ts)--deAnnotate :: AnnExpr bndr annot -> Expr bndr-deAnnotate (_, e) = deAnnotate' e--deAnnotate' :: AnnExpr' bndr annot -> Expr bndr-deAnnotate' (AnnType t)           = Type t-deAnnotate' (AnnCoercion co)      = Coercion co-deAnnotate' (AnnVar  v)           = Var v-deAnnotate' (AnnLit  lit)         = Lit lit-deAnnotate' (AnnLam  binder body) = Lam binder (deAnnotate body)-deAnnotate' (AnnApp  fun arg)     = App (deAnnotate fun) (deAnnotate arg)-deAnnotate' (AnnCast e (_,co))    = Cast (deAnnotate e) co-deAnnotate' (AnnTick tick body)   = Tick tick (deAnnotate body)--deAnnotate' (AnnLet bind body)-  = Let (deAnnBind bind) (deAnnotate body)-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)-collectAnnBndrs e-  = collect [] e-  where-    collect bs (_, AnnLam b body) = collect (b:bs) body-    collect bs body               = (reverse bs, body)---- | As 'collectNBinders' but for 'AnnExpr' rather than 'Expr'-collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)-collectNAnnBndrs orig_n e-  = collect orig_n [] e-  where-    collect 0 bs body               = (reverse bs, body)-    collect n bs (_, AnnLam b body) = collect (n-1) (b:bs) body-    collect _ _  _                  = pprPanic "collectNBinders" $ int orig_n

− compiler/coreSyn/CoreTidy.hs

@@ -1,286 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The AQUA Project, Glasgow University, 1996-1998---This module contains "tidying" code for *nested* expressions, bindings, rules.-The code for *top-level* bindings is in GHC.Iface.Tidy.--}--{-# LANGUAGE CPP #-}-{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}-module CoreTidy (-        tidyExpr, tidyRules, tidyUnfolding-    ) where--#include "HsVersions.h"--import GhcPrelude--import CoreSyn-import CoreSeq ( seqUnfolding )-import Id-import IdInfo-import Demand ( zapUsageEnvSig )-import Type( tidyType, tidyVarBndr )-import Coercion( tidyCo )-import Var-import VarEnv-import UniqFM-import Name hiding (tidyNameOcc)-import SrcLoc-import Maybes-import Data.List--{--************************************************************************-*                                                                      *-\subsection{Tidying expressions, rules}-*                                                                      *-************************************************************************--}--tidyBind :: TidyEnv-         -> CoreBind-         ->  (TidyEnv, CoreBind)--tidyBind env (NonRec bndr rhs)-  = tidyLetBndr env env bndr =: \ (env', bndr') ->-    (env', NonRec bndr' (tidyExpr env' rhs))--tidyBind env (Rec prs)-  = let-       (bndrs, rhss)  = unzip prs-       (env', bndrs') = mapAccumL (tidyLetBndr env') env bndrs-    in-    map (tidyExpr env') rhss =: \ rhss' ->-    (env', Rec (zip bndrs' rhss'))---------------  Expressions  ---------------tidyExpr :: TidyEnv -> CoreExpr -> CoreExpr-tidyExpr env (Var v)       = Var (tidyVarOcc env v)-tidyExpr env (Type ty)     = Type (tidyType env ty)-tidyExpr env (Coercion co) = Coercion (tidyCo env co)-tidyExpr _   (Lit lit)     = Lit lit-tidyExpr env (App f a)     = App (tidyExpr env f) (tidyExpr env a)-tidyExpr env (Tick t e)    = Tick (tidyTickish env t) (tidyExpr env e)-tidyExpr env (Cast e co)   = Cast (tidyExpr env e) (tidyCo env co)--tidyExpr env (Let b e)-  = tidyBind env b      =: \ (env', b') ->-    Let b' (tidyExpr env' e)--tidyExpr env (Case e b ty alts)-  = tidyBndr env b  =: \ (env', b) ->-    Case (tidyExpr env e) b (tidyType env ty)-         (map (tidyAlt env') alts)--tidyExpr env (Lam b e)-  = tidyBndr env b      =: \ (env', b) ->-    Lam b (tidyExpr env' e)--------------  Case alternatives  ---------------tidyAlt :: TidyEnv -> CoreAlt -> CoreAlt-tidyAlt env (con, vs, rhs)-  = tidyBndrs env vs    =: \ (env', vs) ->-    (con, vs, tidyExpr env' rhs)--------------  Tickish  ---------------tidyTickish :: TidyEnv -> Tickish Id -> Tickish Id-tidyTickish env (Breakpoint ix ids) = Breakpoint ix (map (tidyVarOcc env) ids)-tidyTickish _   other_tickish       = other_tickish--------------  Rules  ---------------tidyRules :: TidyEnv -> [CoreRule] -> [CoreRule]-tidyRules _   [] = []-tidyRules env (rule : rules)-  = tidyRule env rule           =: \ rule ->-    tidyRules env rules         =: \ rules ->-    (rule : rules)--tidyRule :: TidyEnv -> CoreRule -> CoreRule-tidyRule _   rule@(BuiltinRule {}) = rule-tidyRule env rule@(Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs,-                          ru_fn = fn, ru_rough = mb_ns })-  = tidyBndrs env bndrs         =: \ (env', bndrs) ->-    map (tidyExpr env') args    =: \ args ->-    rule { ru_bndrs = bndrs, ru_args = args,-           ru_rhs   = tidyExpr env' rhs,-           ru_fn    = tidyNameOcc env fn,-           ru_rough = map (fmap (tidyNameOcc env')) mb_ns }--{--************************************************************************-*                                                                      *-\subsection{Tidying non-top-level binders}-*                                                                      *-************************************************************************--}--tidyNameOcc :: TidyEnv -> Name -> Name--- In rules and instances, we have Names, and we must tidy them too--- Fortunately, we can lookup in the VarEnv with a name-tidyNameOcc (_, var_env) n = case lookupUFM var_env n of-                                Nothing -> n-                                Just v  -> idName v--tidyVarOcc :: TidyEnv -> Var -> Var-tidyVarOcc (_, var_env) v = lookupVarEnv var_env v `orElse` v---- tidyBndr is used for lambda and case binders-tidyBndr :: TidyEnv -> Var -> (TidyEnv, Var)-tidyBndr env var-  | isTyCoVar var = tidyVarBndr env var-  | otherwise     = tidyIdBndr env var--tidyBndrs :: TidyEnv -> [Var] -> (TidyEnv, [Var])-tidyBndrs env vars = mapAccumL tidyBndr env vars---- Non-top-level variables, not covars-tidyIdBndr :: TidyEnv -> Id -> (TidyEnv, Id)-tidyIdBndr env@(tidy_env, var_env) id-  = -- Do this pattern match strictly, otherwise we end up holding on to-    -- stuff in the OccName.-    case tidyOccName tidy_env (getOccName id) of { (tidy_env', occ') ->-    let-        -- Give the Id a fresh print-name, *and* rename its type-        -- The SrcLoc isn't important now,-        -- though we could extract it from the Id-        ---        ty'      = tidyType env (idType id)-        name'    = mkInternalName (idUnique id) occ' noSrcSpan-        id'      = mkLocalIdWithInfo name' ty' new_info-        var_env' = extendVarEnv var_env id id'--        -- Note [Tidy IdInfo]-        new_info = vanillaIdInfo `setOccInfo` occInfo old_info-                                 `setUnfoldingInfo` new_unf-                                  -- see Note [Preserve OneShotInfo]-                                 `setOneShotInfo` oneShotInfo old_info-        old_info = idInfo id-        old_unf  = unfoldingInfo old_info-        new_unf  = zapUnfolding old_unf  -- See Note [Preserve evaluatedness]-    in-    ((tidy_env', var_env'), id')-   }--tidyLetBndr :: TidyEnv         -- Knot-tied version for unfoldings-            -> TidyEnv         -- The one to extend-            -> Id -> (TidyEnv, Id)--- Used for local (non-top-level) let(rec)s--- Just like tidyIdBndr above, but with more IdInfo-tidyLetBndr rec_tidy_env env@(tidy_env, var_env) id-  = case tidyOccName tidy_env (getOccName id) of { (tidy_env', occ') ->-    let-        ty'      = tidyType env (idType id)-        name'    = mkInternalName (idUnique id) occ' noSrcSpan-        details  = idDetails id-        id'      = mkLocalVar details name' ty' new_info-        var_env' = extendVarEnv var_env id id'--        -- Note [Tidy IdInfo]-        -- We need to keep around any interesting strictness and-        -- demand info because later on we may need to use it when-        -- converting to A-normal form.-        -- eg.-        --      f (g x),  where f is strict in its argument, will be converted-        --      into  case (g x) of z -> f z  by CorePrep, but only if f still-        --      has its strictness info.-        ---        -- Similarly for the demand info - on a let binder, this tells-        -- CorePrep to turn the let into a case.-        -- But: Remove the usage demand here-        --      (See Note [Zapping DmdEnv after Demand Analyzer] in WorkWrap)-        ---        -- Similarly arity info for eta expansion in CorePrep-        -- Don't attempt to recompute arity here; this is just tidying!-        -- Trying to do so led to #17294-        ---        -- Set inline-prag info so that we preserve it across-        -- separate compilation boundaries-        old_info = idInfo id-        new_info = vanillaIdInfo-                    `setOccInfo`        occInfo old_info-                    `setArityInfo`      arityInfo old_info-                    `setStrictnessInfo` zapUsageEnvSig (strictnessInfo old_info)-                    `setDemandInfo`     demandInfo old_info-                    `setInlinePragInfo` inlinePragInfo old_info-                    `setUnfoldingInfo`  new_unf--        old_unf = unfoldingInfo old_info-        new_unf | isStableUnfolding old_unf = tidyUnfolding rec_tidy_env old_unf old_unf-                | otherwise                 = zapUnfolding old_unf-                                              -- See Note [Preserve evaluatedness]--    in-    ((tidy_env', var_env'), id') }-------------- Unfolding  ---------------tidyUnfolding :: TidyEnv -> Unfolding -> Unfolding -> Unfolding-tidyUnfolding tidy_env df@(DFunUnfolding { df_bndrs = bndrs, df_args = args }) _-  = df { df_bndrs = bndrs', df_args = map (tidyExpr tidy_env') args }-  where-    (tidy_env', bndrs') = tidyBndrs tidy_env bndrs--tidyUnfolding tidy_env-              unf@(CoreUnfolding { uf_tmpl = unf_rhs, uf_src = src })-              unf_from_rhs-  | isStableSource src-  = 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 (GHC.CoreToIface doesn't look at them)--  | otherwise-  = unf_from_rhs-  where seqIt unf = seqUnfolding unf `seq` unf-tidyUnfolding _ unf _ = unf     -- NoUnfolding or OtherCon--{--Note [Tidy IdInfo]-~~~~~~~~~~~~~~~~~~-All nested Ids now have the same IdInfo, namely vanillaIdInfo, which-should save some space; except that we preserve occurrence info for-two reasons:--  (a) To make printing tidy core nicer--  (b) Because we tidy RULES and InlineRules, which may then propagate-      via --make into the compilation of the next module, and we want-      the benefit of that occurrence analysis when we use the rule or-      or inline the function.  In particular, it's vital not to lose-      loop-breaker info, else we get an infinite inlining loop--Note that tidyLetBndr puts more IdInfo back.--Note [Preserve evaluatedness]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-  data T = MkT !Bool-  ....(case v of MkT y ->-       let z# = case y of-                  True -> 1#-                  False -> 2#-       in ...)--The z# binding is ok because the RHS is ok-for-speculation,-but Lint will complain unless it can *see* that.  So we-preserve the evaluated-ness on 'y' in tidyBndr.--(Another alternative would be to tidy unboxed lets into cases,-but that seems more indirect and surprising.)--Note [Preserve OneShotInfo]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-We keep the OneShotInfo because we want it to propagate into the interface.-Not all OneShotInfo is determined by a compiler analysis; some is added by a-call of GHC.Exts.oneShot, which is then discarded before the end of the-optimisation pipeline, leaving only the OneShotInfo on the lambda. Hence we-must preserve this info in inlinings. See Note [The oneShot function] in MkId.--This applies to lambda binders only, hence it is stored in IfaceLamBndr.--}--(=:) :: a -> (a -> b) -> b-m =: k = m `seq` k m

− compiler/coreSyn/CoreUnfold.hs

@@ -1,1618 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The AQUA Project, Glasgow University, 1994-1998---Core-syntax unfoldings--Unfoldings (which can travel across module boundaries) are in Core-syntax (namely @CoreExpr@s).--The type @Unfolding@ sits ``above'' simply-Core-expressions-unfoldings, capturing ``higher-level'' things we know about a binding,-usually things that the simplifier found out (e.g., ``it's a-literal'').  In the corner of a @CoreUnfolding@ unfolding, you will-find, unsurprisingly, a Core expression.--}--{-# LANGUAGE CPP #-}--{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}--module CoreUnfold (-        Unfolding, UnfoldingGuidance,   -- Abstract types--        noUnfolding, mkImplicitUnfolding,-        mkUnfolding, mkCoreUnfolding,-        mkTopUnfolding, mkSimpleUnfolding, mkWorkerUnfolding,-        mkInlineUnfolding, mkInlineUnfoldingWithArity,-        mkInlinableUnfolding, mkWwInlineRule,-        mkCompulsoryUnfolding, mkDFunUnfolding,-        specUnfolding,--        ArgSummary(..),--        couldBeSmallEnoughToInline, inlineBoringOk,-        certainlyWillInline, smallEnoughToInline,--        callSiteInline, CallCtxt(..),--        -- Reexport from CoreSubst (it only live there so it can be used-        -- by the Very Simple Optimiser)-        exprIsConApp_maybe, exprIsLiteral_maybe-    ) where--#include "HsVersions.h"--import GhcPrelude--import DynFlags-import CoreSyn-import OccurAnal        ( occurAnalyseExpr_NoBinderSwap )-import CoreOpt-import CoreArity       ( manifestArity )-import CoreUtils-import Id-import Demand          ( isBottomingSig )-import DataCon-import Literal-import PrimOp-import IdInfo-import BasicTypes       ( Arity, InlineSpec(..), inlinePragmaSpec )-import Type-import PrelNames-import TysPrim          ( realWorldStatePrimTy )-import Bag-import Util-import Outputable-import ForeignCall-import Name-import ErrUtils--import qualified Data.ByteString as BS-import Data.List--{--************************************************************************-*                                                                      *-\subsection{Making unfoldings}-*                                                                      *-************************************************************************--}--mkTopUnfolding :: DynFlags -> Bool -> CoreExpr -> Unfolding-mkTopUnfolding dflags is_bottoming rhs-  = mkUnfolding dflags InlineRhs True is_bottoming rhs--mkImplicitUnfolding :: DynFlags -> CoreExpr -> Unfolding--- For implicit Ids, do a tiny bit of optimising first-mkImplicitUnfolding dflags expr-  = mkTopUnfolding dflags False (simpleOptExpr dflags expr)---- Note [Top-level flag on inline rules]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- Slight hack: note that mk_inline_rules conservatively sets the--- top-level flag to True.  It gets set more accurately by the simplifier--- Simplify.simplUnfolding.--mkSimpleUnfolding :: DynFlags -> CoreExpr -> Unfolding-mkSimpleUnfolding dflags rhs-  = mkUnfolding dflags InlineRhs False False rhs--mkDFunUnfolding :: [Var] -> DataCon -> [CoreExpr] -> Unfolding-mkDFunUnfolding bndrs con ops-  = DFunUnfolding { df_bndrs = bndrs-                  , df_con = con-                  , df_args = map occurAnalyseExpr_NoBinderSwap ops }-                  -- See Note [Occurrence analysis of unfoldings]--mkWwInlineRule :: DynFlags -> CoreExpr -> Arity -> Unfolding-mkWwInlineRule dflags expr arity-  = mkCoreUnfolding InlineStable True-                   (simpleOptExpr dflags expr)-                   (UnfWhen { ug_arity = arity, ug_unsat_ok = unSaturatedOk-                            , ug_boring_ok = boringCxtNotOk })--mkCompulsoryUnfolding :: CoreExpr -> Unfolding-mkCompulsoryUnfolding expr         -- Used for things that absolutely must be unfolded-  = mkCoreUnfolding InlineCompulsory True-                    (simpleOptExpr unsafeGlobalDynFlags expr)-                    (UnfWhen { ug_arity = 0    -- Arity of unfolding doesn't matter-                             , ug_unsat_ok = unSaturatedOk, ug_boring_ok = boringCxtOk })--mkWorkerUnfolding :: DynFlags -> (CoreExpr -> CoreExpr) -> Unfolding -> Unfolding--- See Note [Worker-wrapper for INLINABLE functions] in WorkWrap-mkWorkerUnfolding dflags work_fn-                  (CoreUnfolding { uf_src = src, uf_tmpl = tmpl-                                 , uf_is_top = top_lvl })-  | isStableSource src-  = mkCoreUnfolding src top_lvl new_tmpl guidance-  where-    new_tmpl = simpleOptExpr dflags (work_fn tmpl)-    guidance = calcUnfoldingGuidance dflags False new_tmpl--mkWorkerUnfolding _ _ _ = noUnfolding---- | Make an unfolding that may be used unsaturated--- (ug_unsat_ok = unSaturatedOk) and that is reported as having its--- manifest arity (the number of outer lambdas applications will--- resolve before doing any work).-mkInlineUnfolding :: CoreExpr -> Unfolding-mkInlineUnfolding expr-  = mkCoreUnfolding InlineStable-                    True         -- Note [Top-level flag on inline rules]-                    expr' guide-  where-    expr' = simpleOptExpr unsafeGlobalDynFlags expr-    guide = UnfWhen { ug_arity = manifestArity expr'-                    , ug_unsat_ok = unSaturatedOk-                    , ug_boring_ok = boring_ok }-    boring_ok = inlineBoringOk expr'---- | Make an unfolding that will be used once the RHS has been saturated--- to the given arity.-mkInlineUnfoldingWithArity :: Arity -> CoreExpr -> Unfolding-mkInlineUnfoldingWithArity arity expr-  = mkCoreUnfolding InlineStable-                    True         -- Note [Top-level flag on inline rules]-                    expr' guide-  where-    expr' = simpleOptExpr unsafeGlobalDynFlags expr-    guide = UnfWhen { ug_arity = arity-                    , ug_unsat_ok = needSaturated-                    , ug_boring_ok = boring_ok }-    -- See Note [INLINE pragmas and boring contexts] as to why we need to look-    -- at the arity here.-    boring_ok | arity == 0 = True-              | otherwise  = inlineBoringOk expr'--mkInlinableUnfolding :: DynFlags -> CoreExpr -> Unfolding-mkInlinableUnfolding dflags expr-  = mkUnfolding dflags InlineStable False False expr'-  where-    expr' = simpleOptExpr dflags expr--specUnfolding :: DynFlags -> [Var] -> (CoreExpr -> CoreExpr) -> Arity-              -> Unfolding -> Unfolding--- See Note [Specialising unfoldings]--- specUnfolding spec_bndrs spec_app arity_decrease unf---   = \spec_bndrs. spec_app( unf )----specUnfolding dflags spec_bndrs spec_app arity_decrease-              df@(DFunUnfolding { df_bndrs = old_bndrs, df_con = con, df_args = args })-  = ASSERT2( arity_decrease == count isId old_bndrs - count isId spec_bndrs, ppr df )-    mkDFunUnfolding spec_bndrs con (map spec_arg args)-      -- There is a hard-to-check assumption here that the spec_app has-      -- enough applications to exactly saturate the old_bndrs-      -- For DFunUnfoldings we transform-      --       \old_bndrs. MkD <op1> ... <opn>-      -- to-      --       \new_bndrs. MkD (spec_app(\old_bndrs. <op1>)) ... ditto <opn>-      -- The ASSERT checks the value part of that-  where-    spec_arg arg = simpleOptExpr dflags (spec_app (mkLams old_bndrs arg))-                   -- The beta-redexes created by spec_app will be-                   -- simplified away by simplOptExpr--specUnfolding dflags spec_bndrs spec_app arity_decrease-              (CoreUnfolding { uf_src = src, uf_tmpl = tmpl-                             , uf_is_top = top_lvl-                             , uf_guidance = old_guidance })- | isStableSource src  -- See Note [Specialising unfoldings]- , UnfWhen { ug_arity     = old_arity-           , ug_unsat_ok  = unsat_ok-           , ug_boring_ok = boring_ok } <- old_guidance- = let guidance = UnfWhen { ug_arity     = old_arity - arity_decrease-                          , ug_unsat_ok  = unsat_ok-                          , ug_boring_ok = boring_ok }-       new_tmpl = simpleOptExpr dflags (mkLams spec_bndrs (spec_app tmpl))-                   -- The beta-redexes created by spec_app will be-                   -- simplified away by simplOptExpr--   in mkCoreUnfolding src top_lvl new_tmpl guidance--specUnfolding _ _ _ _ _ = noUnfolding--{- Note [Specialising unfoldings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we specialise a function for some given type-class arguments, we use-specUnfolding to specialise its unfolding.  Some important points:--* If the original function has a DFunUnfolding, the specialised one-  must do so too!  Otherwise we lose the magic rules that make it-  interact with ClassOps--* There is a bit of hack for INLINABLE functions:-     f :: Ord a => ....-     f = <big-rhs>-     {- INLINABLE f #-}-  Now if we specialise f, should the specialised version still have-  an INLINABLE pragma?  If it does, we'll capture a specialised copy-  of <big-rhs> as its unfolding, and that probably won't inline.  But-  if we don't, the specialised version of <big-rhs> might be small-  enough to inline at a call site. This happens with Control.Monad.liftM3,-  and can cause a lot more allocation as a result (nofib n-body shows this).--  Moreover, keeping the INLINABLE thing isn't much help, because-  the specialised function (probably) isn't overloaded any more.--  Conclusion: drop the INLINEALE pragma.  In practice what this means is:-     if a stable unfolding has UnfoldingGuidance of UnfWhen,-        we keep it (so the specialised thing too will always inline)-     if a stable unfolding has UnfoldingGuidance of UnfIfGoodArgs-        (which arises from INLINABLE), we discard it--Note [Honour INLINE on 0-ary bindings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider--   x = <expensive>-   {-# INLINE x #-}--   f y = ...x...--The semantics of an INLINE pragma is--  inline x at every call site, provided it is saturated;-  that is, applied to at least as many arguments as appear-  on the LHS of the Haskell source definition.--(This source-code-derived arity is stored in the `ug_arity` field of-the `UnfoldingGuidance`.)--In the example, x's ug_arity is 0, so we should inline it at every use-site.  It's rare to have such an INLINE pragma (usually INLINE Is on-functions), but it's occasionally very important (#15578, #15519).-In #15519 we had something like-   x = case (g a b) of I# r -> T r-   {-# INLINE x #-}-   f y = ...(h x)....--where h is strict.  So we got-   f y = ...(case g a b of I# r -> h (T r))...--and that in turn allowed SpecConstr to ramp up performance.--How do we deliver on this?  By adjusting the ug_boring_ok-flag in mkInlineUnfoldingWithArity; see-Note [INLINE pragmas and boring contexts]--NB: there is a real risk that full laziness will float it right back-out again. Consider again-  x = factorial 200-  {-# INLINE x #-}-  f y = ...x...--After inlining we get-  f y = ...(factorial 200)...--but it's entirely possible that full laziness will do-  lvl23 = factorial 200-  f y = ...lvl23...--That's a problem for another day.--Note [INLINE pragmas and boring contexts]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-An INLINE pragma uses mkInlineUnfoldingWithArity to build the-unfolding.  That sets the ug_boring_ok flag to False if the function-is not tiny (inlineBoringOK), so that even INLINE functions are not-inlined in an utterly boring context.  E.g.-     \x y. Just (f y x)-Nothing is gained by inlining f here, even if it has an INLINE-pragma.--But for 0-ary bindings, we want to inline regardless; see-Note [Honour INLINE on 0-ary bindings].--I'm a bit worried that it's possible for the same kind of problem-to arise for non-0-ary functions too, but let's wait and see.--}--mkCoreUnfolding :: UnfoldingSource -> Bool -> CoreExpr-                -> UnfoldingGuidance -> Unfolding--- Occurrence-analyses the expression before capturing it-mkCoreUnfolding src top_lvl expr guidance-  = CoreUnfolding { uf_tmpl         = occurAnalyseExpr_NoBinderSwap expr,-                      -- See Note [Occurrence analysis of unfoldings]-                    uf_src          = src,-                    uf_is_top       = top_lvl,-                    uf_is_value     = exprIsHNF        expr,-                    uf_is_conlike   = exprIsConLike    expr,-                    uf_is_work_free = exprIsWorkFree   expr,-                    uf_expandable   = exprIsExpandable expr,-                    uf_guidance     = guidance }--mkUnfolding :: DynFlags -> UnfoldingSource-            -> Bool       -- Is top-level-            -> Bool       -- Definitely a bottoming binding-                          -- (only relevant for top-level bindings)-            -> CoreExpr-            -> Unfolding--- Calculates unfolding guidance--- Occurrence-analyses the expression before capturing it-mkUnfolding dflags src is_top_lvl is_bottoming expr-  = CoreUnfolding { uf_tmpl         = occurAnalyseExpr_NoBinderSwap expr,-                      -- See Note [Occurrence analysis of unfoldings]-                    uf_src          = src,-                    uf_is_top       = is_top_lvl,-                    uf_is_value     = exprIsHNF        expr,-                    uf_is_conlike   = exprIsConLike    expr,-                    uf_expandable   = exprIsExpandable expr,-                    uf_is_work_free = exprIsWorkFree   expr,-                    uf_guidance     = guidance }-  where-    is_top_bottoming = is_top_lvl && is_bottoming-    guidance         = calcUnfoldingGuidance dflags is_top_bottoming expr-        -- NB: *not* (calcUnfoldingGuidance (occurAnalyseExpr_NoBinderSwap expr))!-        -- See Note [Calculate unfolding guidance on the non-occ-anal'd expression]--{--Note [Occurrence analysis of unfoldings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We do occurrence-analysis of unfoldings once and for all, when the-unfolding is built, rather than each time we inline them.--But given this decision it's vital that we do-*always* do it.  Consider this unfolding-    \x -> letrec { f = ...g...; g* = f } in body-where g* is (for some strange reason) the loop breaker.  If we don't-occ-anal it when reading it in, we won't mark g as a loop breaker, and-we may inline g entirely in body, dropping its binding, and leaving-the occurrence in f out of scope. This happened in #8892, where-the unfolding in question was a DFun unfolding.--But more generally, the simplifier is designed on the-basis that it is looking at occurrence-analysed expressions, so better-ensure that they actually are.--We use occurAnalyseExpr_NoBinderSwap instead of occurAnalyseExpr;-see Note [No binder swap in unfoldings].--Note [No binder swap in unfoldings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The binder swap can temporarily violate Core Lint, by assigning-a LocalId binding to a GlobalId. For example, if A.foo{r872}-is a GlobalId with unique r872, then-- case A.foo{r872} of bar {-   K x -> ...(A.foo{r872})...- }--gets transformed to--  case A.foo{r872} of bar {-    K x -> let foo{r872} = bar-           in ...(A.foo{r872})...--This is usually not a problem, because the simplifier will transform-this to:--  case A.foo{r872} of bar {-    K x -> ...(bar)...--However, after occurrence analysis but before simplification, this extra 'let'-violates the Core Lint invariant that we do not have local 'let' bindings for-GlobalIds.  That seems (just) tolerable for the occurrence analysis that happens-just before the Simplifier, but not for unfoldings, which are Linted-independently.-As a quick workaround, we disable binder swap in this module.-See #16288 and #16296 for further plans.--Note [Calculate unfolding guidance on the non-occ-anal'd expression]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Notice that we give the non-occur-analysed expression to-calcUnfoldingGuidance.  In some ways it'd be better to occur-analyse-first; for example, sometimes during simplification, there's a large-let-bound thing which has been substituted, and so is now dead; so-'expr' contains two copies of the thing while the occurrence-analysed-expression doesn't.--Nevertheless, we *don't* and *must not* occ-analyse before computing-the size because--a) The size computation bales out after a while, whereas occurrence-   analysis does not.--b) Residency increases sharply if you occ-anal first.  I'm not-   100% sure why, but it's a large effect.  Compiling Cabal went-   from residency of 534M to over 800M with this one change.--This can occasionally mean that the guidance is very pessimistic;-it gets fixed up next round.  And it should be rare, because large-let-bound things that are dead are usually caught by preInlineUnconditionally---************************************************************************-*                                                                      *-\subsection{The UnfoldingGuidance type}-*                                                                      *-************************************************************************--}--inlineBoringOk :: CoreExpr -> Bool--- See Note [INLINE for small functions]--- True => the result of inlining the expression is---         no bigger than the expression itself---     eg      (\x y -> f y x)--- This is a quick and dirty version. It doesn't attempt--- to deal with  (\x y z -> x (y z))--- The really important one is (x `cast` c)-inlineBoringOk e-  = go 0 e-  where-    go :: Int -> CoreExpr -> Bool-    go credit (Lam x e) | isId x           = go (credit+1) e-                        | otherwise        = go credit e-    go credit (App f a) | isTyCoArg a      = go credit f-                        | credit > 0-                        , exprIsTrivial a  = go (credit-1) f-    go credit (Tick _ e)                   = go credit e -- dubious-    go credit (Cast e _)                   = go credit e-    go _      (Var {})                     = boringCxtOk-    go _      _                            = boringCxtNotOk--calcUnfoldingGuidance-        :: DynFlags-        -> Bool          -- Definitely a top-level, bottoming binding-        -> CoreExpr      -- Expression to look at-        -> UnfoldingGuidance-calcUnfoldingGuidance dflags is_top_bottoming (Tick t expr)-  | not (tickishIsCode t)  -- non-code ticks don't matter for unfolding-  = calcUnfoldingGuidance dflags is_top_bottoming expr-calcUnfoldingGuidance dflags is_top_bottoming expr-  = case sizeExpr dflags bOMB_OUT_SIZE val_bndrs body of-      TooBig -> UnfNever-      SizeIs size cased_bndrs scrut_discount-        | uncondInline expr n_val_bndrs size-        -> UnfWhen { ug_unsat_ok = unSaturatedOk-                   , ug_boring_ok =  boringCxtOk-                   , ug_arity = n_val_bndrs }   -- Note [INLINE for small functions]--        | is_top_bottoming-        -> UnfNever   -- See Note [Do not inline top-level bottoming functions]--        | otherwise-        -> UnfIfGoodArgs { ug_args  = map (mk_discount cased_bndrs) val_bndrs-                         , ug_size  = size-                         , ug_res   = scrut_discount }--  where-    (bndrs, body) = collectBinders expr-    bOMB_OUT_SIZE = ufCreationThreshold dflags-           -- Bomb out if size gets bigger than this-    val_bndrs   = filter isId bndrs-    n_val_bndrs = length val_bndrs--    mk_discount :: Bag (Id,Int) -> Id -> Int-    mk_discount cbs bndr = foldl' combine 0 cbs-           where-             combine acc (bndr', disc)-               | bndr == bndr' = acc `plus_disc` disc-               | otherwise     = acc--             plus_disc :: Int -> Int -> Int-             plus_disc | isFunTy (idType bndr) = max-                       | otherwise             = (+)-             -- See Note [Function and non-function discounts]--{--Note [Computing the size of an expression]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The basic idea of sizeExpr is obvious enough: count nodes.  But getting the-heuristics right has taken a long time.  Here's the basic strategy:--    * Variables, literals: 0-      (Exception for string literals, see litSize.)--    * Function applications (f e1 .. en): 1 + #value args--    * Constructor applications: 1, regardless of #args--    * Let(rec): 1 + size of components--    * Note, cast: 0--Examples--  Size  Term-  ---------------    0     42#-    0     x-    0     True-    2     f x-    1     Just x-    4     f (g x)--Notice that 'x' counts 0, while (f x) counts 2.  That's deliberate: there's-a function call to account for.  Notice also that constructor applications-are very cheap, because exposing them to a caller is so valuable.--[25/5/11] All sizes are now multiplied by 10, except for primops-(which have sizes like 1 or 4.  This makes primops look fantastically-cheap, and seems to be almost universally beneficial.  Done partly as a-result of #4978.--Note [Do not inline top-level bottoming functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The FloatOut pass has gone to some trouble to float out calls to 'error'-and similar friends.  See Note [Bottoming floats] in SetLevels.-Do not re-inline them!  But we *do* still inline if they are very small-(the uncondInline stuff).--Note [INLINE for small functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider        {-# INLINE f #-}-                f x = Just x-                g y = f y-Then f's RHS is no larger than its LHS, so we should inline it into-even the most boring context.  In general, f the function is-sufficiently small that its body is as small as the call itself, the-inline unconditionally, regardless of how boring the context is.--Things to note:--(1) We inline *unconditionally* if inlined thing is smaller (using sizeExpr)-    than the thing it's replacing.  Notice that-      (f x) --> (g 3)             -- YES, unconditionally-      (f x) --> x : []            -- YES, *even though* there are two-                                  --      arguments to the cons-      x     --> g 3               -- NO-      x     --> Just v            -- NO--    It's very important not to unconditionally replace a variable by-    a non-atomic term.--(2) We do this even if the thing isn't saturated, else we end up with the-    silly situation that-       f x y = x-       ...map (f 3)...-    doesn't inline.  Even in a boring context, inlining without being-    saturated will give a lambda instead of a PAP, and will be more-    efficient at runtime.--(3) However, when the function's arity > 0, we do insist that it-    has at least one value argument at the call site.  (This check is-    made in the UnfWhen case of callSiteInline.) Otherwise we find this:-         f = /\a \x:a. x-         d = /\b. MkD (f b)-    If we inline f here we get-         d = /\b. MkD (\x:b. x)-    and then prepareRhs floats out the argument, abstracting the type-    variables, so we end up with the original again!--(4) We must be much more cautious about arity-zero things. Consider-       let x = y +# z in ...-    In *size* terms primops look very small, because the generate a-    single instruction, but we do not want to unconditionally replace-    every occurrence of x with (y +# z).  So we only do the-    unconditional-inline thing for *trivial* expressions.--    NB: you might think that PostInlineUnconditionally would do this-    but it doesn't fire for top-level things; see SimplUtils-    Note [Top level and postInlineUnconditionally]--}--uncondInline :: CoreExpr -> Arity -> Int -> Bool--- Inline unconditionally if there no size increase--- Size of call is arity (+1 for the function)--- See Note [INLINE for small functions]-uncondInline rhs arity size-  | arity > 0 = size <= 10 * (arity + 1) -- See Note [INLINE for small functions] (1)-  | otherwise = exprIsTrivial rhs        -- See Note [INLINE for small functions] (4)--sizeExpr :: DynFlags-         -> Int             -- Bomb out if it gets bigger than this-         -> [Id]            -- Arguments; we're interested in which of these-                            -- get case'd-         -> CoreExpr-         -> ExprSize---- Note [Computing the size of an expression]--sizeExpr dflags bOMB_OUT_SIZE top_args expr-  = size_up expr-  where-    size_up (Cast e _) = size_up e-    size_up (Tick _ e) = size_up e-    size_up (Type _)   = sizeZero           -- Types cost nothing-    size_up (Coercion _) = sizeZero-    size_up (Lit lit)  = sizeN (litSize lit)-    size_up (Var f) | isRealWorldId f = sizeZero-                      -- Make sure we get constructor discounts even-                      -- on nullary constructors-                    | otherwise       = size_up_call f [] 0--    size_up (App fun arg)-      | isTyCoArg arg = size_up fun-      | otherwise     = size_up arg  `addSizeNSD`-                        size_up_app fun [arg] (if isRealWorldExpr arg then 1 else 0)--    size_up (Lam b e)-      | isId b && not (isRealWorldId b) = lamScrutDiscount dflags (size_up e `addSizeN` 10)-      | otherwise = size_up e--    size_up (Let (NonRec binder rhs) body)-      = size_up_rhs (binder, rhs) `addSizeNSD`-        size_up body              `addSizeN`-        size_up_alloc binder--    size_up (Let (Rec pairs) body)-      = foldr (addSizeNSD . size_up_rhs)-              (size_up body `addSizeN` sum (map (size_up_alloc . fst) pairs))-              pairs--    size_up (Case e _ _ alts)-        | null alts-        = size_up e    -- case e of {} never returns, so take size of scrutinee--    size_up (Case e _ _ alts)-        -- Now alts is non-empty-        | Just v <- is_top_arg e -- We are scrutinising an argument variable-        = let-            alt_sizes = map size_up_alt alts--                  -- alts_size tries to compute a good discount for-                  -- the case when we are scrutinising an argument variable-            alts_size (SizeIs tot tot_disc tot_scrut)-                          -- Size of all alternatives-                      (SizeIs max _        _)-                          -- Size of biggest alternative-                  = SizeIs tot (unitBag (v, 20 + tot - max)-                      `unionBags` tot_disc) tot_scrut-                          -- If the variable is known, we produce a-                          -- discount that will take us back to 'max',-                          -- the size of the largest alternative The-                          -- 1+ is a little discount for reduced-                          -- allocation in the caller-                          ---                          -- Notice though, that we return tot_disc,-                          -- the total discount from all branches.  I-                          -- think that's right.--            alts_size tot_size _ = tot_size-          in-          alts_size (foldr1 addAltSize alt_sizes)  -- alts is non-empty-                    (foldr1 maxSize    alt_sizes)-                -- Good to inline if an arg is scrutinised, because-                -- that may eliminate allocation in the caller-                -- And it eliminates the case itself-        where-          is_top_arg (Var v) | v `elem` top_args = Just v-          is_top_arg (Cast e _) = is_top_arg e-          is_top_arg _ = Nothing---    size_up (Case e _ _ alts) = size_up e  `addSizeNSD`-                                foldr (addAltSize . size_up_alt) case_size alts-      where-          case_size-           | 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,-                -- below) to account for the cost of the info table-                -- and comparisons.-                ---                -- However, in certain cases (see is_inline_scrut-                -- below), no code is generated for the case unless-                -- there are multiple alts.  In these cases we-                -- subtract one, making the first alt free.-                -- e.g. case x# +# y# of _ -> ...   should cost 1-                --      case touch# x# of _ -> ...  should cost 0-                -- (see #4978)-                ---                -- 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)--                -- unboxed variables, inline primops and unsafe foreign calls-                -- are all "inline" things:-          is_inline_scrut (Var v) = isUnliftedType (idType v)-          is_inline_scrut scrut-              | (Var f, _) <- collectArgs scrut-                = case idDetails f of-                    FCallId fc  -> not (isSafeForeignCall fc)-                    PrimOpId op -> not (primOpOutOfLine op)-                    _other      -> False-              | otherwise-                = False--    size_up_rhs (bndr, rhs)-      | Just join_arity <- isJoinId_maybe bndr-        -- Skip arguments to join point-      , (_bndrs, body) <- collectNBinders join_arity rhs-      = size_up body-      | otherwise-      = size_up rhs--    -------------    -- size_up_app is used when there's ONE OR MORE value args-    size_up_app (App fun arg) args voids-        | isTyCoArg arg                  = size_up_app fun args voids-        | isRealWorldExpr arg            = size_up_app fun (arg:args) (voids + 1)-        | otherwise                      = size_up arg  `addSizeNSD`-                                           size_up_app fun (arg:args) voids-    size_up_app (Var fun)     args voids = size_up_call fun args voids-    size_up_app (Tick _ expr) args voids = size_up_app expr args voids-    size_up_app (Cast expr _) args voids = size_up_app expr args voids-    size_up_app other         args voids = size_up other `addSizeN`-                                           callSize (length args) voids-       -- if the lhs is not an App or a Var, or an invisible thing like a-       -- Tick or Cast, then we should charge for a complete call plus the-       -- size of the lhs itself.--    -------------    size_up_call :: Id -> [CoreExpr] -> Int -> ExprSize-    size_up_call fun val_args voids-       = case idDetails fun of-           FCallId _        -> sizeN (callSize (length val_args) voids)-           DataConWorkId dc -> conSize    dc (length val_args)-           PrimOpId op      -> primOpSize op (length val_args)-           ClassOpId _      -> classOpSize dflags top_args val_args-           _                -> funSize dflags top_args fun (length val_args) voids--    -------------    size_up_alt (_con, _bndrs, rhs) = size_up rhs `addSizeN` 10-        -- Don't charge for args, so that wrappers look cheap-        -- (See comments about wrappers with Case)-        ---        -- 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--    -------------    -- Cost to allocate binding with given binder-    size_up_alloc bndr-      |  isTyVar bndr                 -- Doesn't exist at runtime-      || isJoinId bndr                -- Not allocated at all-      || isUnliftedType (idType bndr) -- Doesn't live in heap-      = 0-      | otherwise-      = 10--    -------------        -- These addSize things have to be here because-        -- I don't want to give them bOMB_OUT_SIZE as an argument-    addSizeN TooBig          _  = TooBig-    addSizeN (SizeIs n xs d) m  = mkSizeIs bOMB_OUT_SIZE (n + m) xs d--        -- addAltSize is used to add the sizes of case alternatives-    addAltSize TooBig            _      = TooBig-    addAltSize _                 TooBig = TooBig-    addAltSize (SizeIs n1 xs d1) (SizeIs n2 ys d2)-        = mkSizeIs bOMB_OUT_SIZE (n1 + n2)-                                 (xs `unionBags` ys)-                                 (d1 + d2) -- Note [addAltSize result discounts]--        -- This variant ignores the result discount from its LEFT argument-        -- It's used when the second argument isn't part of the result-    addSizeNSD TooBig            _      = TooBig-    addSizeNSD _                 TooBig = TooBig-    addSizeNSD (SizeIs n1 xs _) (SizeIs n2 ys d2)-        = mkSizeIs bOMB_OUT_SIZE (n1 + n2)-                                 (xs `unionBags` ys)-                                 d2  -- Ignore d1--    isRealWorldId id = idType id `eqType` realWorldStatePrimTy--    -- an expression of type State# RealWorld must be a variable-    isRealWorldExpr (Var id)   = isRealWorldId id-    isRealWorldExpr (Tick _ e) = isRealWorldExpr e-    isRealWorldExpr _          = False---- | Finds a nominal size of a string literal.-litSize :: Literal -> Int--- Used by CoreUnfold.sizeExpr-litSize (LitNumber LitNumInteger _ _) = 100   -- Note [Size of literal integers]-litSize (LitNumber LitNumNatural _ _) = 100-litSize (LitString str) = 10 + 10 * ((BS.length str + 3) `div` 4)-        -- If size could be 0 then @f "x"@ might be too small-        -- [Sept03: make literal strings a bit bigger to avoid fruitless-        --  duplication of little strings]-litSize _other = 0    -- Must match size of nullary constructors-                      -- Key point: if  x |-> 4, then x must inline unconditionally-                      --            (eg via case binding)--classOpSize :: DynFlags -> [Id] -> [CoreExpr] -> ExprSize--- See Note [Conlike is interesting]-classOpSize _ _ []-  = sizeZero-classOpSize dflags top_args (arg1 : other_args)-  = SizeIs size arg_discount 0-  where-    size = 20 + (10 * length other_args)-    -- If the class op is scrutinising a lambda bound dictionary then-    -- give it a discount, to encourage the inlining of this function-    -- The actual discount is rather arbitrarily chosen-    arg_discount = case arg1 of-                     Var dict | dict `elem` top_args-                              -> unitBag (dict, ufDictDiscount dflags)-                     _other   -> emptyBag---- | The size of a function call-callSize- :: Int  -- ^ number of value args- -> Int  -- ^ number of value args that are void- -> Int-callSize n_val_args voids = 10 * (1 + n_val_args - voids)-        -- The 1+ is for the function itself-        -- Add 1 for each non-trivial arg;-        -- the allocation cost, as in let(rec)---- | The size of a jump to a join point-jumpSize- :: Int  -- ^ number of value args- -> Int  -- ^ number of value args that are void- -> Int-jumpSize n_val_args voids = 2 * (1 + n_val_args - voids)-  -- A jump is 20% the size of a function call. Making jumps free reopens-  -- bug #6048, but making them any more expensive loses a 21% improvement in-  -- spectral/puzzle. TODO Perhaps adjusting the default threshold would be a-  -- better solution?--funSize :: DynFlags -> [Id] -> Id -> Int -> Int -> ExprSize--- Size for functions that are not constructors or primops--- Note [Function applications]-funSize dflags top_args fun n_val_args voids-  | fun `hasKey` buildIdKey   = buildSize-  | fun `hasKey` augmentIdKey = augmentSize-  | otherwise = SizeIs size arg_discount res_discount-  where-    some_val_args = n_val_args > 0-    is_join = isJoinId fun--    size | is_join              = jumpSize n_val_args voids-         | not some_val_args    = 0-         | otherwise            = callSize n_val_args voids--        --                  DISCOUNTS-        --  See Note [Function and non-function discounts]-    arg_discount | some_val_args && fun `elem` top_args-                 = unitBag (fun, ufFunAppDiscount dflags)-                 | otherwise = emptyBag-        -- If the function is an argument and is applied-        -- to some values, give it an arg-discount--    res_discount | idArity fun > n_val_args = ufFunAppDiscount dflags-                 | otherwise                = 0-        -- If the function is partially applied, show a result discount--- XXX maybe behave like ConSize for eval'd variable--conSize :: DataCon -> Int -> ExprSize-conSize dc n_val_args-  | n_val_args == 0 = SizeIs 0 emptyBag 10    -- Like variables---- See Note [Unboxed tuple size and result discount]-  | isUnboxedTupleCon dc = SizeIs 0 emptyBag (10 * (1 + n_val_args))---- See Note [Constructor size and result discount]-  | otherwise = SizeIs 10 emptyBag (10 * (1 + n_val_args))---- XXX still looks to large to me--{--Note [Constructor size and result discount]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Treat a constructors application as size 10, regardless of how many-arguments it has; we are keen to expose them (and we charge separately-for their args).  We can't treat them as size zero, else we find that-(Just x) has size 0, which is the same as a lone variable; and hence-'v' will always be replaced by (Just x), where v is bound to Just x.--The "result discount" is applied if the result of the call is-scrutinised (say by a case).  For a constructor application that will-mean the constructor application will disappear, so we don't need to-charge it to the function.  So the discount should at least match the-cost of the constructor application, namely 10.  But to give a bit-of extra incentive we give a discount of 10*(1 + n_val_args).--Simon M tried a MUCH bigger discount: (10 * (10 + n_val_args)),-and said it was an "unambiguous win", but its terribly dangerous-because a function with many many case branches, each finishing with-a constructor, can have an arbitrarily large discount.  This led to-terrible code bloat: see #6099.--Note [Unboxed tuple size and result discount]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-However, unboxed tuples count as size zero. I found occasions where we had-        f x y z = case op# x y z of { s -> (# s, () #) }-and f wasn't getting inlined.--I tried giving unboxed tuples a *result discount* of zero (see the-commented-out line).  Why?  When returned as a result they do not-allocate, so maybe we don't want to charge so much for them If you-have a non-zero discount here, we find that workers often get inlined-back into wrappers, because it look like-    f x = case $wf x of (# a,b #) -> (a,b)-and we are keener because of the case.  However while this change-shrank binary sizes by 0.5% it also made spectral/boyer allocate 5%-more. All other changes were very small. So it's not a big deal but I-didn't adopt the idea.--Note [Function and non-function discounts]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We want a discount if the function is applied. A good example is-monadic combinators with continuation arguments, where inlining is-quite important.--But we don't want a big discount when a function is called many times-(see the detailed comments with #6048) because if the function is-big it won't be inlined at its many call sites and no benefit results.-Indeed, we can get exponentially big inlinings this way; that is what-#6048 is about.--On the other hand, for data-valued arguments, if there are lots of-case expressions in the body, each one will get smaller if we apply-the function to a constructor application, so we *want* a big discount-if the argument is scrutinised by many case expressions.--Conclusion:-  - For functions, take the max of the discounts-  - For data values, take the sum of the discounts---Note [Literal integer size]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-Literal integers *can* be big (mkInteger [...coefficients...]), but-need not be (S# n).  We just use an arbitrary big-ish constant here-so that, in particular, we don't inline top-level defns like-   n = S# 5-There's no point in doing so -- any optimisations will see the S#-through n's unfolding.  Nor will a big size inhibit unfoldings functions-that mention a literal Integer, because the float-out pass will float-all those constants to top level.--}--primOpSize :: PrimOp -> Int -> ExprSize-primOpSize op n_val_args- = if primOpOutOfLine op-      then sizeN (op_size + n_val_args)-      else sizeN op_size- where-   op_size = primOpCodeSize op---buildSize :: ExprSize-buildSize = SizeIs 0 emptyBag 40-        -- We really want to inline applications of build-        -- build t (\cn -> e) should cost only the cost of e (because build will be inlined later)-        -- Indeed, we should add a result_discount because build is-        -- very like a constructor.  We don't bother to check that the-        -- build is saturated (it usually is).  The "-2" discounts for the \c n,-        -- The "4" is rather arbitrary.--augmentSize :: ExprSize-augmentSize = SizeIs 0 emptyBag 40-        -- Ditto (augment t (\cn -> e) ys) should cost only the cost of-        -- e plus ys. The -2 accounts for the \cn---- When we return a lambda, give a discount if it's used (applied)-lamScrutDiscount :: DynFlags -> ExprSize -> ExprSize-lamScrutDiscount dflags (SizeIs n vs _) = SizeIs n vs (ufFunAppDiscount dflags)-lamScrutDiscount _      TooBig          = TooBig--{--Note [addAltSize result discounts]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When adding the size of alternatives, we *add* the result discounts-too, rather than take the *maximum*.  For a multi-branch case, this-gives a discount for each branch that returns a constructor, making us-keener to inline.  I did try using 'max' instead, but it makes nofib-'rewrite' and 'puzzle' allocate significantly more, and didn't make-binary sizes shrink significantly either.--Note [Discounts and thresholds]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Constants for discounts and thesholds are defined in main/DynFlags,-all of form ufXxxx.   They are:--ufCreationThreshold-     At a definition site, if the unfolding is bigger than this, we-     may discard it altogether--ufUseThreshold-     At a call site, if the unfolding, less discounts, is smaller than-     this, then it's small enough inline--ufKeenessFactor-     Factor by which the discounts are multiplied before-     subtracting from size--ufDictDiscount-     The discount for each occurrence of a dictionary argument-     as an argument of a class method.  Should be pretty small-     else big functions may get inlined--ufFunAppDiscount-     Discount for a function argument that is applied.  Quite-     large, because if we inline we avoid the higher-order call.--ufDearOp-     The size of a foreign call or not-dupable PrimOp--ufVeryAggressive-     If True, the compiler ignores all the thresholds and inlines very-     aggressively. It still adheres to arity, simplifier phase control and-     loop breakers.---Note [Function applications]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In a function application (f a b)--  - If 'f' is an argument to the function being analysed,-    and there's at least one value arg, record a FunAppDiscount for f--  - If the application if a PAP (arity > 2 in this example)-    record a *result* discount (because inlining-    with "extra" args in the call may mean that we now-    get a saturated application)--Code for manipulating sizes--}---- | The size of a candidate expression for unfolding-data ExprSize-    = TooBig-    | SizeIs { _es_size_is  :: {-# UNPACK #-} !Int -- ^ Size found-             , _es_args     :: !(Bag (Id,Int))-               -- ^ Arguments cased herein, and discount for each such-             , _es_discount :: {-# UNPACK #-} !Int-               -- ^ Size to subtract if result is scrutinised by a case-               -- expression-             }--instance Outputable ExprSize where-  ppr TooBig         = text "TooBig"-  ppr (SizeIs a _ c) = brackets (int a <+> int c)---- subtract the discount before deciding whether to bale out. eg. we--- want to inline a large constructor application into a selector:---      tup = (a_1, ..., a_99)---      x = case tup of ...----mkSizeIs :: Int -> Int -> Bag (Id, Int) -> Int -> ExprSize-mkSizeIs max n xs d | (n - d) > max = TooBig-                    | otherwise     = SizeIs n xs d--maxSize :: ExprSize -> ExprSize -> ExprSize-maxSize TooBig         _                                  = TooBig-maxSize _              TooBig                             = TooBig-maxSize s1@(SizeIs n1 _ _) s2@(SizeIs n2 _ _) | n1 > n2   = s1-                                              | otherwise = s2--sizeZero :: ExprSize-sizeN :: Int -> ExprSize--sizeZero = SizeIs 0 emptyBag 0-sizeN n  = SizeIs n emptyBag 0--{--************************************************************************-*                                                                      *-\subsection[considerUnfolding]{Given all the info, do (not) do the unfolding}-*                                                                      *-************************************************************************--We use 'couldBeSmallEnoughToInline' to avoid exporting inlinings that-we ``couldn't possibly use'' on the other side.  Can be overridden w/-flaggery.  Just the same as smallEnoughToInline, except that it has no-actual arguments.--}--couldBeSmallEnoughToInline :: DynFlags -> Int -> CoreExpr -> Bool-couldBeSmallEnoughToInline dflags threshold rhs-  = case sizeExpr dflags threshold [] body of-       TooBig -> False-       _      -> True-  where-    (_, body) = collectBinders rhs-------------------smallEnoughToInline :: DynFlags -> Unfolding -> Bool-smallEnoughToInline dflags (CoreUnfolding {uf_guidance = UnfIfGoodArgs {ug_size = size}})-  = size <= ufUseThreshold dflags-smallEnoughToInline _ _-  = False--------------------certainlyWillInline :: DynFlags -> IdInfo -> Maybe Unfolding--- ^ Sees if the unfolding is pretty certain to inline.--- If so, return a *stable* unfolding for it, that will always inline.-certainlyWillInline dflags fn_info-  = case unfoldingInfo fn_info of-      CoreUnfolding { uf_tmpl = e, uf_guidance = g }-        | loop_breaker -> Nothing      -- Won't inline, so try w/w-        | noinline     -> Nothing      -- See Note [Worker-wrapper for NOINLINE functions]-        | otherwise    -> do_cunf e g  -- Depends on size, so look at that--      DFunUnfolding {} -> Just fn_unf  -- Don't w/w DFuns; it never makes sense-                                       -- to do so, and even if it is currently a-                                       -- loop breaker, it may not be later--      _other_unf       -> Nothing--  where-    loop_breaker = isStrongLoopBreaker (occInfo fn_info)-    noinline     = inlinePragmaSpec (inlinePragInfo fn_info) == NoInline-    fn_unf       = unfoldingInfo fn_info--    do_cunf :: CoreExpr -> UnfoldingGuidance -> Maybe Unfolding-    do_cunf _ UnfNever     = Nothing-    do_cunf _ (UnfWhen {}) = Just (fn_unf { uf_src = InlineStable })-                             -- INLINE functions have UnfWhen--        -- The UnfIfGoodArgs case seems important.  If we w/w small functions-        -- binary sizes go up by 10%!  (This is with SplitObjs.)-        -- I'm not totally sure why.-        -- INLINABLE functions come via this path-        --    See Note [certainlyWillInline: INLINABLE]-    do_cunf expr (UnfIfGoodArgs { ug_size = size, ug_args = args })-      | arityInfo fn_info > 0  -- See Note [certainlyWillInline: be careful of thunks]-      , not (isBottomingSig (strictnessInfo fn_info))-              -- Do not unconditionally inline a bottoming functions even if-              -- it seems smallish. We've carefully lifted it out to top level,-              -- so we don't want to re-inline it.-      , let unf_arity = length args-      , size - (10 * (unf_arity + 1)) <= ufUseThreshold dflags-      = Just (fn_unf { uf_src      = InlineStable-                     , uf_guidance = UnfWhen { ug_arity     = unf_arity-                                             , ug_unsat_ok  = unSaturatedOk-                                             , ug_boring_ok = inlineBoringOk expr } })-             -- Note the "unsaturatedOk". A function like  f = \ab. a-             -- will certainly inline, even if partially applied (f e), so we'd-             -- better make sure that the transformed inlining has the same property-      | otherwise-      = Nothing--{- Note [certainlyWillInline: be careful of thunks]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Don't claim that thunks will certainly inline, because that risks work-duplication.  Even if the work duplication is not great (eg is_cheap-holds), it can make a big difference in an inner loop In #5623 we-found that the WorkWrap phase thought that-       y = case x of F# v -> F# (v +# v)-was certainlyWillInline, so the addition got duplicated.--Note that we check arityInfo instead of the arity of the unfolding to detect-this case. This is so that we don't accidentally fail to inline small partial-applications, like `f = g 42` (where `g` recurses into `f`) where g has arity 2-(say). Here there is no risk of work duplication, and the RHS is tiny, so-certainlyWillInline should return True. But `unf_arity` is zero! However f's-arity, gotten from `arityInfo fn_info`, is 1.--Failing to say that `f` will inline forces W/W to generate a potentially huge-worker for f that will immediately cancel with `g`'s wrapper anyway, causing-unnecessary churn in the Simplifier while arriving at the same result.--Note [certainlyWillInline: INLINABLE]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-certainlyWillInline /must/ return Nothing for a large INLINABLE thing,-even though we have a stable inlining, so that strictness w/w takes-place.  It makes a big difference to efficiency, and the w/w pass knows-how to transfer the INLINABLE info to the worker; see WorkWrap-Note [Worker-wrapper for INLINABLE functions]--************************************************************************-*                                                                      *-\subsection{callSiteInline}-*                                                                      *-************************************************************************--This is the key function.  It decides whether to inline a variable at a call site--callSiteInline is used at call sites, so it is a bit more generous.-It's a very important function that embodies lots of heuristics.-A non-WHNF can be inlined if it doesn't occur inside a lambda,-and occurs exactly once or-    occurs once in each branch of a case and is small--If the thing is in WHNF, there's no danger of duplicating work,-so we can inline if it occurs once, or is small--NOTE: we don't want to inline top-level functions that always diverge.-It just makes the code bigger.  Tt turns out that the convenient way to prevent-them inlining is to give them a NOINLINE pragma, which we do in-StrictAnal.addStrictnessInfoToTopId--}--callSiteInline :: DynFlags-               -> Id                    -- The Id-               -> Bool                  -- True <=> unfolding is active-               -> Bool                  -- True if there are no arguments at all (incl type args)-               -> [ArgSummary]          -- One for each value arg; True if it is interesting-               -> CallCtxt              -- True <=> continuation is interesting-               -> Maybe CoreExpr        -- Unfolding, if any--data ArgSummary = TrivArg       -- Nothing interesting-                | NonTrivArg    -- Arg has structure-                | ValueArg      -- Arg is a con-app or PAP-                                -- ..or con-like. Note [Conlike is interesting]--instance Outputable ArgSummary where-  ppr TrivArg    = text "TrivArg"-  ppr NonTrivArg = text "NonTrivArg"-  ppr ValueArg   = text "ValueArg"--nonTriv ::  ArgSummary -> Bool-nonTriv TrivArg = False-nonTriv _       = True--data CallCtxt-  = BoringCtxt-  | RhsCtxt             -- Rhs of a let-binding; see Note [RHS of lets]-  | DiscArgCtxt         -- Argument of a function with non-zero arg discount-  | RuleArgCtxt         -- We are somewhere in the argument of a function with rules--  | ValAppCtxt          -- We're applied to at least one value arg-                        -- This arises when we have ((f x |> co) y)-                        -- Then the (f x) has argument 'x' but in a ValAppCtxt--  | CaseCtxt            -- We're the scrutinee of a case-                        -- that decomposes its scrutinee--instance Outputable CallCtxt where-  ppr CaseCtxt    = text "CaseCtxt"-  ppr ValAppCtxt  = text "ValAppCtxt"-  ppr BoringCtxt  = text "BoringCtxt"-  ppr RhsCtxt     = text "RhsCtxt"-  ppr DiscArgCtxt = text "DiscArgCtxt"-  ppr RuleArgCtxt = text "RuleArgCtxt"--callSiteInline dflags id active_unfolding lone_variable arg_infos cont_info-  = case idUnfolding id of-      -- idUnfolding checks for loop-breakers, returning NoUnfolding-      -- Things with an INLINE pragma may have an unfolding *and*-      -- be a loop breaker  (maybe the knot is not yet untied)-        CoreUnfolding { uf_tmpl = unf_template-                      , uf_is_work_free = is_wf-                      , uf_guidance = guidance, uf_expandable = is_exp }-          | active_unfolding -> tryUnfolding dflags id lone_variable-                                    arg_infos cont_info unf_template-                                    is_wf is_exp guidance-          | otherwise -> traceInline dflags id "Inactive unfolding:" (ppr id) Nothing-        NoUnfolding      -> Nothing-        BootUnfolding    -> Nothing-        OtherCon {}      -> Nothing-        DFunUnfolding {} -> Nothing     -- Never unfold a DFun--traceInline :: DynFlags -> Id -> String -> SDoc -> a -> a-traceInline dflags inline_id str doc result- | Just prefix <- inlineCheck dflags- =  if prefix `isPrefixOf` occNameString (getOccName inline_id)-      then traceAction dflags str doc result-      else result- | dopt Opt_D_dump_inlinings dflags && dopt Opt_D_verbose_core2core dflags- = traceAction dflags str doc result- | otherwise- = result--tryUnfolding :: DynFlags -> Id -> Bool -> [ArgSummary] -> CallCtxt-             -> CoreExpr -> Bool -> Bool -> UnfoldingGuidance-             -> Maybe CoreExpr-tryUnfolding dflags id lone_variable-             arg_infos cont_info unf_template-             is_wf is_exp guidance- = case guidance of-     UnfNever -> traceInline dflags id str (text "UnfNever") Nothing--     UnfWhen { ug_arity = uf_arity, ug_unsat_ok = unsat_ok, ug_boring_ok = boring_ok }-        | enough_args && (boring_ok || some_benefit || ufVeryAggressive dflags)-                -- See Note [INLINE for small functions (3)]-        -> traceInline dflags id str (mk_doc some_benefit empty True) (Just unf_template)-        | otherwise-        -> traceInline dflags id str (mk_doc some_benefit empty False) Nothing-        where-          some_benefit = calc_some_benefit uf_arity-          enough_args = (n_val_args >= uf_arity) || (unsat_ok && n_val_args > 0)--     UnfIfGoodArgs { ug_args = arg_discounts, ug_res = res_discount, ug_size = size }-        | ufVeryAggressive dflags-        -> traceInline dflags id str (mk_doc some_benefit extra_doc True) (Just unf_template)-        | is_wf && some_benefit && small_enough-        -> traceInline dflags id str (mk_doc some_benefit extra_doc True) (Just unf_template)-        | otherwise-        -> traceInline dflags id str (mk_doc some_benefit extra_doc False) Nothing-        where-          some_benefit = calc_some_benefit (length arg_discounts)-          extra_doc = text "discounted size =" <+> int discounted_size-          discounted_size = size - discount-          small_enough = discounted_size <= ufUseThreshold dflags-          discount = computeDiscount dflags arg_discounts-                                     res_discount arg_infos cont_info--  where-    mk_doc some_benefit extra_doc yes_or_no-      = vcat [ text "arg infos" <+> ppr arg_infos-             , text "interesting continuation" <+> ppr cont_info-             , text "some_benefit" <+> ppr some_benefit-             , text "is exp:" <+> ppr is_exp-             , text "is work-free:" <+> ppr is_wf-             , text "guidance" <+> ppr guidance-             , extra_doc-             , text "ANSWER =" <+> if yes_or_no then text "YES" else text "NO"]--    str = "Considering inlining: " ++ showSDocDump dflags (ppr id)-    n_val_args = length arg_infos--           -- some_benefit is used when the RHS is small enough-           -- and the call has enough (or too many) value-           -- arguments (ie n_val_args >= arity). But there must-           -- be *something* interesting about some argument, or the-           -- result context, to make it worth inlining-    calc_some_benefit :: Arity -> Bool   -- The Arity is the number of args-                                         -- expected by the unfolding-    calc_some_benefit uf_arity-       | not saturated = interesting_args       -- Under-saturated-                                        -- Note [Unsaturated applications]-       | otherwise = interesting_args   -- Saturated or over-saturated-                  || interesting_call-      where-        saturated      = n_val_args >= uf_arity-        over_saturated = n_val_args > uf_arity-        interesting_args = any nonTriv arg_infos-                -- NB: (any nonTriv arg_infos) looks at the-                -- over-saturated args too which is "wrong";-                -- but if over-saturated we inline anyway.--        interesting_call-          | over_saturated-          = True-          | otherwise-          = case cont_info of-              CaseCtxt   -> not (lone_variable && is_exp)  -- Note [Lone variables]-              ValAppCtxt -> True                           -- Note [Cast then apply]-              RuleArgCtxt -> uf_arity > 0  -- See Note [Unfold info lazy contexts]-              DiscArgCtxt -> uf_arity > 0  -- Note [Inlining in ArgCtxt]-              RhsCtxt     -> uf_arity > 0  ---              _other      -> False         -- See Note [Nested functions]---{--Note [Unfold into lazy contexts], Note [RHS of lets]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When the call is the argument of a function with a RULE, or the RHS of a let,-we are a little bit keener to inline.  For example-     f y = (y,y,y)-     g y = let x = f y in ...(case x of (a,b,c) -> ...) ...-We'd inline 'f' if the call was in a case context, and it kind-of-is,-only we can't see it.  Also-     x = f v-could be expensive whereas-     x = case v of (a,b) -> a-is patently cheap and may allow more eta expansion.-So we treat the RHS of a let as not-totally-boring.--Note [Unsaturated applications]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When a call is not saturated, we *still* inline if one of the-arguments has interesting structure.  That's sometimes very important.-A good example is the Ord instance for Bool in Base:-- Rec {-    $fOrdBool =GHC.Classes.D:Ord-                 @ Bool-                 ...-                 $cmin_ajX--    $cmin_ajX [Occ=LoopBreaker] :: Bool -> Bool -> Bool-    $cmin_ajX = GHC.Classes.$dmmin @ Bool $fOrdBool-  }--But the defn of GHC.Classes.$dmmin is:--  $dmmin :: forall a. GHC.Classes.Ord a => a -> a -> a-    {- Arity: 3, HasNoCafRefs, Strictness: SLL,-       Unfolding: (\ @ a $dOrd :: GHC.Classes.Ord a x :: a y :: a ->-                   case @ a GHC.Classes.<= @ a $dOrd x y of wild {-                     GHC.Types.False -> y GHC.Types.True -> x }) -}--We *really* want to inline $dmmin, even though it has arity 3, in-order to unravel the recursion.---Note [Things to watch]-~~~~~~~~~~~~~~~~~~~~~~-*   { y = I# 3; x = y `cast` co; ...case (x `cast` co) of ... }-    Assume x is exported, so not inlined unconditionally.-    Then we want x to inline unconditionally; no reason for it-    not to, and doing so avoids an indirection.--*   { x = I# 3; ....f x.... }-    Make sure that x does not inline unconditionally!-    Lest we get extra allocation.--Note [Inlining an InlineRule]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-An InlineRules is used for-  (a) programmer INLINE pragmas-  (b) inlinings from worker/wrapper--For (a) the RHS may be large, and our contract is that we *only* inline-when the function is applied to all the arguments on the LHS of the-source-code defn.  (The uf_arity in the rule.)--However for worker/wrapper it may be worth inlining even if the-arity is not satisfied (as we do in the CoreUnfolding case) so we don't-require saturation.--Note [Nested functions]-~~~~~~~~~~~~~~~~~~~~~~~-At one time we treated a call of a non-top-level function as-"interesting" (regardless of how boring the context) in the hope-that inlining it would eliminate the binding, and its allocation.-Specifically, in the default case of interesting_call we had-   _other -> not is_top && uf_arity > 0--But actually postInlineUnconditionally does some of this and overall-it makes virtually no difference to nofib.  So I simplified away this-special case--Note [Cast then apply]-~~~~~~~~~~~~~~~~~~~~~~-Consider-   myIndex = __inline_me ( (/\a. <blah>) |> co )-   co :: (forall a. a -> a) ~ (forall a. T a)-     ... /\a.\x. case ((myIndex a) |> sym co) x of { ... } ...--We need to inline myIndex to unravel this; but the actual call (myIndex a) has-no value arguments.  The ValAppCtxt gives it enough incentive to inline.--Note [Inlining in ArgCtxt]-~~~~~~~~~~~~~~~~~~~~~~~~~~-The condition (arity > 0) here is very important, because otherwise-we end up inlining top-level stuff into useless places; eg-   x = I# 3#-   f = \y.  g x-This can make a very big difference: it adds 16% to nofib 'integer' allocs,-and 20% to 'power'.--At one stage I replaced this condition by 'True' (leading to the above-slow-down).  The motivation was test eyeball/inline1.hs; but that seems-to work ok now.--NOTE: arguably, we should inline in ArgCtxt only if the result of the-call is at least CONLIKE.  At least for the cases where we use ArgCtxt-for the RHS of a 'let', we only profit from the inlining if we get a-CONLIKE thing (modulo lets).--Note [Lone variables]   See also Note [Interaction of exprIsWorkFree and lone variables]-~~~~~~~~~~~~~~~~~~~~~   which appears below-The "lone-variable" case is important.  I spent ages messing about-with unsatisfactory variants, but this is nice.  The idea is that if a-variable appears all alone--        as an arg of lazy fn, or rhs    BoringCtxt-        as scrutinee of a case          CaseCtxt-        as arg of a fn                  ArgCtxt-AND-        it is bound to a cheap expression--then we should not inline it (unless there is some other reason,-e.g. it is the sole occurrence).  That is what is happening at-the use of 'lone_variable' in 'interesting_call'.--Why?  At least in the case-scrutinee situation, turning-        let x = (a,b) in case x of y -> ...-into-        let x = (a,b) in case (a,b) of y -> ...-and thence to-        let x = (a,b) in let y = (a,b) in ...-is bad if the binding for x will remain.--Another example: I discovered that strings-were getting inlined straight back into applications of 'error'-because the latter is strict.-        s = "foo"-        f = \x -> ...(error s)...--Fundamentally such contexts should not encourage inlining because, provided-the RHS is "expandable" (see Note [exprIsExpandable] in CoreUtils) the-context can ``see'' the unfolding of the variable (e.g. case or a-RULE) so there's no gain.--However, watch out:-- * Consider this:-        foo = _inline_ (\n. [n])-        bar = _inline_ (foo 20)-        baz = \n. case bar of { (m:_) -> m + n }-   Here we really want to inline 'bar' so that we can inline 'foo'-   and the whole thing unravels as it should obviously do.  This is-   important: in the NDP project, 'bar' generates a closure data-   structure rather than a list.--   So the non-inlining of lone_variables should only apply if the-   unfolding is regarded as cheap; because that is when exprIsConApp_maybe-   looks through the unfolding.  Hence the "&& is_wf" in the-   InlineRule branch.-- * Even a type application or coercion isn't a lone variable.-   Consider-        case $fMonadST @ RealWorld of { :DMonad a b c -> c }-   We had better inline that sucker!  The case won't see through it.--   For now, I'm treating treating a variable applied to types-   in a *lazy* context "lone". The motivating example was-        f = /\a. \x. BIG-        g = /\a. \y.  h (f a)-   There's no advantage in inlining f here, and perhaps-   a significant disadvantage.  Hence some_val_args in the Stop case--Note [Interaction of exprIsWorkFree and lone variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The lone-variable test says "don't inline if a case expression-scrutinises a lone variable whose unfolding is cheap".  It's very-important that, under these circumstances, exprIsConApp_maybe-can spot a constructor application. So, for example, we don't-consider-        let x = e in (x,x)-to be cheap, and that's good because exprIsConApp_maybe doesn't-think that expression is a constructor application.--In the 'not (lone_variable && is_wf)' test, I used to test is_value-rather than is_wf, which was utterly wrong, because the above-expression responds True to exprIsHNF, which is what sets is_value.--This kind of thing can occur if you have--        {-# INLINE foo #-}-        foo = let x = e in (x,x)--which Roman did.----}--computeDiscount :: DynFlags -> [Int] -> Int -> [ArgSummary] -> CallCtxt-                -> Int-computeDiscount dflags arg_discounts res_discount arg_infos cont_info-        -- We multiple the raw discounts (args_discount and result_discount)-        -- ty opt_UnfoldingKeenessFactor because the former have to do with-        --  *size* whereas the discounts imply that there's some extra-        --  *efficiency* to be gained (e.g. beta reductions, case reductions)-        -- by inlining.--  = 10          -- Discount of 10 because the result replaces the call-                -- so we count 10 for the function itself--    + 10 * length actual_arg_discounts-               -- Discount of 10 for each arg supplied,-               -- because the result replaces the call--    + round (ufKeenessFactor dflags *-             fromIntegral (total_arg_discount + res_discount'))-  where-    actual_arg_discounts = zipWith mk_arg_discount arg_discounts arg_infos-    total_arg_discount   = sum actual_arg_discounts--    mk_arg_discount _        TrivArg    = 0-    mk_arg_discount _        NonTrivArg = 10-    mk_arg_discount discount ValueArg   = discount--    res_discount'-      | LT <- arg_discounts `compareLength` arg_infos-      = 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-                -- 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-                --   for RuleArgCtxt we do want to be keener to inline; but not only-                --       constructor results-                --   for RhsCtxt I suppose that exposing a data con is good in general-                --   And 40 seems very arbitrary-                ---                -- res_discount can be very large when a function returns-                -- constructors; but we only want to invoke that large discount-                -- when there's a case continuation.-                -- Otherwise we, rather arbitrarily, threshold it.  Yuk.-                -- But we want to avoid inlining large functions that return-                -- constructors into contexts that are simply "interesting"

− compiler/coreSyn/CoreUnfold.hs-boot

@@ -1,14 +0,0 @@-module CoreUnfold (-        mkUnfolding-    ) where--import GhcPrelude-import CoreSyn-import DynFlags--mkUnfolding :: DynFlags-            -> UnfoldingSource-            -> Bool-            -> Bool-            -> CoreExpr-            -> Unfolding

− compiler/coreSyn/CoreUtils.hs

@@ -1,2675 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998---Utility functions on @Core@ syntax--}--{-# LANGUAGE CPP #-}---- | Commonly useful utilities for manipulating the Core language-module CoreUtils (-        -- * Constructing expressions-        mkCast,-        mkTick, mkTicks, mkTickNoHNF, tickHNFArgs,-        bindNonRec, needsCaseBinding,-        mkAltExpr, mkDefaultCase, mkSingleAltCase,--        -- * Taking expressions apart-        findDefault, addDefault, findAlt, isDefaultAlt,-        mergeAlts, trimConArgs,-        filterAlts, combineIdenticalAlts, refineDefaultAlt,--        -- * Properties of expressions-        exprType, coreAltType, coreAltsType, isExprLevPoly,-        exprIsDupable, exprIsTrivial, getIdFromTrivialExpr, exprIsBottom,-        getIdFromTrivialExpr_maybe,-        exprIsCheap, exprIsExpandable, exprIsCheapX, CheapAppFun,-        exprIsHNF, exprOkForSpeculation, exprOkForSideEffects, exprIsWorkFree,-        exprIsBig, exprIsConLike,-        rhsIsStatic, isCheapApp, isExpandableApp,-        exprIsTickedString, exprIsTickedString_maybe,-        exprIsTopLevelBindable,-        altsAreExhaustive,--        -- * Equality-        cheapEqExpr, cheapEqExpr', eqExpr,-        diffExpr, diffBinds,--        -- * Eta reduction-        tryEtaReduce,--        -- * Manipulating data constructors and types-        exprToType, exprToCoercion_maybe,-        applyTypeToArgs, applyTypeToArg,-        dataConRepInstPat, dataConRepFSInstPat,-        isEmptyTy,--        -- * Working with ticks-        stripTicksTop, stripTicksTopE, stripTicksTopT,-        stripTicksE, stripTicksT,--        -- * StaticPtr-        collectMakeStaticArgs,--        -- * Join points-        isJoinBind-    ) where--#include "HsVersions.h"--import GhcPrelude--import CoreSyn-import PrelNames ( makeStaticName )-import PprCore-import CoreFVs( exprFreeVars )-import Var-import SrcLoc-import VarEnv-import VarSet-import Name-import Literal-import DataCon-import PrimOp-import Id-import IdInfo-import PrelNames( absentErrorIdKey )-import Type-import Predicate-import TyCoRep( TyCoBinder(..), TyBinder )-import Coercion-import TyCon-import Unique-import Outputable-import TysPrim-import DynFlags-import FastString-import Maybes-import ListSetOps       ( minusList )-import BasicTypes       ( Arity, isConLike )-import GHC.Platform-import Util-import Pair-import Data.ByteString     ( ByteString )-import Data.Function       ( on )-import Data.List-import Data.Ord            ( comparing )-import OrdList-import qualified Data.Set as Set-import UniqSet--{--************************************************************************-*                                                                      *-\subsection{Find the type of a Core atom/expression}-*                                                                      *-************************************************************************--}--exprType :: CoreExpr -> Type--- ^ Recover the type of a well-typed Core expression. Fails when--- applied to the actual 'CoreSyn.Type' expression as it cannot--- really be said to have a type-exprType (Var var)           = idType var-exprType (Lit lit)           = literalType lit-exprType (Coercion co)       = coercionType co-exprType (Let bind body)-  | NonRec tv rhs <- bind    -- See Note [Type bindings]-  , Type ty <- rhs           = substTyWithUnchecked [tv] [ty] (exprType body)-  | otherwise                = exprType body-exprType (Case _ _ ty _)     = ty-exprType (Cast _ co)         = pSnd (coercionKind co)-exprType (Tick _ e)          = exprType e-exprType (Lam binder expr)   = mkLamType binder (exprType expr)-exprType e@(App _ _)-  = case collectArgs e of-        (fun, args) -> applyTypeToArgs e (exprType fun) args--exprType other = pprTrace "exprType" (pprCoreExpr other) alphaTy--coreAltType :: CoreAlt -> Type--- ^ Returns the type of the alternatives right hand side-coreAltType alt@(_,bs,rhs)-  = case occCheckExpand bs rhs_ty of-      -- Note [Existential variables and silly type synonyms]-      Just ty -> ty-      Nothing -> pprPanic "coreAltType" (pprCoreAlt alt $$ ppr rhs_ty)-  where-    rhs_ty = exprType rhs--coreAltsType :: [CoreAlt] -> Type--- ^ Returns the type of the first alternative, which should be the same as for all alternatives-coreAltsType (alt:_) = coreAltType alt-coreAltsType []      = panic "corAltsType"---- | Is this expression levity polymorphic? This should be the--- same as saying (isKindLevPoly . typeKind . exprType) but--- much faster.-isExprLevPoly :: CoreExpr -> Bool-isExprLevPoly = go-  where-   go (Var _)                      = False  -- no levity-polymorphic binders-   go (Lit _)                      = False  -- no levity-polymorphic literals-   go e@(App f _) | not (go_app f) = False-                  | otherwise      = check_type e-   go (Lam _ _)                    = False-   go (Let _ e)                    = go e-   go e@(Case {})                  = check_type e -- checking type is fast-   go e@(Cast {})                  = check_type e-   go (Tick _ e)                   = go e-   go e@(Type {})                  = pprPanic "isExprLevPoly ty" (ppr e)-   go (Coercion {})                = False  -- this case can happen in SetLevels--   check_type = isTypeLevPoly . exprType  -- slow approach--      -- if the function is a variable (common case), check its-      -- levityInfo. This might mean we don't need to look up and compute-      -- on the type. Spec of these functions: return False if there is-      -- no possibility, ever, of this expression becoming levity polymorphic,-      -- no matter what it's applied to; return True otherwise.-      -- returning True is always safe. See also Note [Levity info] in-      -- IdInfo-   go_app (Var id)        = not (isNeverLevPolyId id)-   go_app (Lit _)         = False-   go_app (App f _)       = go_app f-   go_app (Lam _ e)       = go_app e-   go_app (Let _ e)       = go_app e-   go_app (Case _ _ ty _) = resultIsLevPoly ty-   go_app (Cast _ co)     = resultIsLevPoly (coercionRKind co)-   go_app (Tick _ e)      = go_app e-   go_app e@(Type {})     = pprPanic "isExprLevPoly app ty" (ppr e)-   go_app e@(Coercion {}) = pprPanic "isExprLevPoly app co" (ppr e)---{--Note [Type bindings]-~~~~~~~~~~~~~~~~~~~~-Core does allow type bindings, although such bindings are-not much used, except in the output of the desugarer.-Example:-     let a = Int in (\x:a. x)-Given this, exprType must be careful to substitute 'a' in the-result type (#8522).--Note [Existential variables and silly type synonyms]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-        data T = forall a. T (Funny a)-        type Funny a = Bool-        f :: T -> Bool-        f (T x) = x--Now, the type of 'x' is (Funny a), where 'a' is existentially quantified.-That means that 'exprType' and 'coreAltsType' may give a result that *appears*-to mention an out-of-scope type variable.  See #3409 for a more real-world-example.--Various possibilities suggest themselves:-- - Ignore the problem, and make Lint not complain about such variables-- - Expand all type synonyms (or at least all those that discard arguments)-      This is tricky, because at least for top-level things we want to-      retain the type the user originally specified.-- - Expand synonyms on the fly, when the problem arises. That is what-   we are doing here.  It's not too expensive, I think.--Note that there might be existentially quantified coercion variables, too.--}---- Not defined with applyTypeToArg because you can't print from CoreSyn.-applyTypeToArgs :: CoreExpr -> Type -> [CoreExpr] -> Type--- ^ A more efficient version of 'applyTypeToArg' when we have several arguments.--- The first argument is just for debugging, and gives some context-applyTypeToArgs e op_ty args-  = go op_ty args-  where-    go op_ty []                   = op_ty-    go op_ty (Type ty : args)     = go_ty_args op_ty [ty] args-    go op_ty (Coercion co : args) = go_ty_args op_ty [mkCoercionTy co] args-    go op_ty (_ : args)           | Just (_, res_ty) <- splitFunTy_maybe op_ty-                                  = go res_ty args-    go _ _ = pprPanic "applyTypeToArgs" panic_msg--    -- go_ty_args: accumulate type arguments so we can-    -- instantiate all at once with piResultTys-    go_ty_args op_ty rev_tys (Type ty : args)-       = go_ty_args op_ty (ty:rev_tys) args-    go_ty_args op_ty rev_tys (Coercion co : args)-       = go_ty_args op_ty (mkCoercionTy co : rev_tys) args-    go_ty_args op_ty rev_tys args-       = go (piResultTys op_ty (reverse rev_tys)) args--    panic_msg = vcat [ text "Expression:" <+> pprCoreExpr e-                     , text "Type:" <+> ppr op_ty-                     , text "Args:" <+> ppr args ]---{--************************************************************************-*                                                                      *-\subsection{Attaching notes}-*                                                                      *-************************************************************************--}---- | Wrap the given expression in the coercion safely, dropping--- identity coercions and coalescing nested coercions-mkCast :: CoreExpr -> CoercionR -> CoreExpr-mkCast e co-  | ASSERT2( coercionRole co == Representational-           , text "coercion" <+> ppr co <+> ptext (sLit "passed to mkCast")-             <+> ppr e <+> text "has wrong role" <+> ppr (coercionRole co) )-    isReflCo co-  = e--mkCast (Coercion e_co) co-  | isCoVarType (coercionRKind co)-       -- The guard here checks that g has a (~#) on both sides,-       -- otherwise decomposeCo fails.  Can in principle happen-       -- with unsafeCoerce-  = Coercion (mkCoCast e_co co)--mkCast (Cast expr co2) co-  = WARN(let { from_ty = coercionLKind co;-               to_ty2  = coercionRKind co2 } in-            not (from_ty `eqType` to_ty2),-             vcat ([ text "expr:" <+> ppr expr-                   , text "co2:" <+> ppr co2-                   , text "co:" <+> ppr co ]) )-    mkCast expr (mkTransCo co2 co)--mkCast (Tick t expr) co-   = Tick t (mkCast expr co)--mkCast expr co-  = let from_ty = coercionLKind co in-    WARN( not (from_ty `eqType` exprType expr),-          text "Trying to coerce" <+> text "(" <> ppr expr-          $$ text "::" <+> ppr (exprType expr) <> text ")"-          $$ ppr co $$ ppr (coercionType co) )-    (Cast expr co)---- | Wraps the given expression in the source annotation, dropping the--- annotation if possible.-mkTick :: Tickish Id -> CoreExpr -> CoreExpr-mkTick t orig_expr = mkTick' id id orig_expr- where-  -- Some ticks (cost-centres) can be split in two, with the-  -- non-counting part having laxer placement properties.-  canSplit = tickishCanSplit t && tickishPlace (mkNoCount t) /= tickishPlace t--  mkTick' :: (CoreExpr -> CoreExpr) -- ^ apply after adding tick (float through)-          -> (CoreExpr -> CoreExpr) -- ^ apply before adding tick (float with)-          -> CoreExpr               -- ^ current expression-          -> CoreExpr-  mkTick' top rest expr = case expr of--    -- Cost centre ticks should never be reordered relative to each-    -- other. Therefore we can stop whenever two collide.-    Tick t2 e-      | ProfNote{} <- t2, ProfNote{} <- t -> top $ Tick t $ rest expr--    -- Otherwise we assume that ticks of different placements float-    -- through each other.-      | tickishPlace t2 /= tickishPlace t -> mkTick' (top . Tick t2) rest e--    -- For annotations this is where we make sure to not introduce-    -- redundant ticks.-      | tickishContains t t2              -> mkTick' top rest e-      | tickishContains t2 t              -> orig_expr-      | otherwise                         -> mkTick' top (rest . Tick t2) e--    -- Ticks don't care about types, so we just float all ticks-    -- through them. Note that it's not enough to check for these-    -- cases top-level. While mkTick will never produce Core with type-    -- expressions below ticks, such constructs can be the result of-    -- unfoldings. We therefore make an effort to put everything into-    -- the right place no matter what we start with.-    Cast e co   -> mkTick' (top . flip Cast co) rest e-    Coercion co -> Coercion co--    Lam x e-      -- Always float through type lambdas. Even for non-type lambdas,-      -- floating is allowed for all but the most strict placement rule.-      | not (isRuntimeVar x) || tickishPlace t /= PlaceRuntime-      -> mkTick' (top . Lam x) rest e--      -- If it is both counting and scoped, we split the tick into its-      -- two components, often allowing us to keep the counting tick on-      -- the outside of the lambda and push the scoped tick inside.-      -- The point of this is that the counting tick can probably be-      -- floated, and the lambda may then be in a position to be-      -- beta-reduced.-      | canSplit-      -> top $ Tick (mkNoScope t) $ rest $ Lam x $ mkTick (mkNoCount t) e--    App f arg-      -- Always float through type applications.-      | not (isRuntimeArg arg)-      -> mkTick' (top . flip App arg) rest f--      -- We can also float through constructor applications, placement-      -- permitting. Again we can split.-      | isSaturatedConApp expr && (tickishPlace t==PlaceCostCentre || canSplit)-      -> if tickishPlace t == PlaceCostCentre-         then top $ rest $ tickHNFArgs t expr-         else top $ Tick (mkNoScope t) $ rest $ tickHNFArgs (mkNoCount t) expr--    Var x-      | notFunction && tickishPlace t == PlaceCostCentre-      -> orig_expr-      | notFunction && canSplit-      -> top $ Tick (mkNoScope t) $ rest expr-      where-        -- SCCs can be eliminated on variables provided the variable-        -- is not a function.  In these cases the SCC makes no difference:-        -- the cost of evaluating the variable will be attributed to its-        -- definition site.  When the variable refers to a function, however,-        -- an SCC annotation on the variable affects the cost-centre stack-        -- when the function is called, so we must retain those.-        notFunction = not (isFunTy (idType x))--    Lit{}-      | tickishPlace t == PlaceCostCentre-      -> orig_expr--    -- Catch-all: Annotate where we stand-    _any -> top $ Tick t $ rest expr--mkTicks :: [Tickish Id] -> CoreExpr -> CoreExpr-mkTicks ticks expr = foldr mkTick expr ticks--isSaturatedConApp :: CoreExpr -> Bool-isSaturatedConApp e = go e []-  where go (App f a) as = go f (a:as)-        go (Var fun) args-           = isConLikeId fun && idArity fun == valArgCount args-        go (Cast f _) as = go f as-        go _ _ = False--mkTickNoHNF :: Tickish Id -> CoreExpr -> CoreExpr-mkTickNoHNF t e-  | exprIsHNF e = tickHNFArgs t e-  | otherwise   = mkTick t e---- push a tick into the arguments of a HNF (call or constructor app)-tickHNFArgs :: Tickish Id -> CoreExpr -> CoreExpr-tickHNFArgs t e = push t e- where-  push t (App f (Type u)) = App (push t f) (Type u)-  push t (App f arg) = App (push t f) (mkTick t arg)-  push _t e = e---- | Strip ticks satisfying a predicate from top of an expression-stripTicksTop :: (Tickish Id -> Bool) -> Expr b -> ([Tickish Id], Expr b)-stripTicksTop p = go []-  where go ts (Tick t e) | p t = go (t:ts) e-        go ts other            = (reverse ts, other)---- | Strip ticks satisfying a predicate from top of an expression,--- returning the remaining expression-stripTicksTopE :: (Tickish Id -> Bool) -> Expr b -> Expr b-stripTicksTopE p = go-  where go (Tick t e) | p t = go e-        go other            = other---- | Strip ticks satisfying a predicate from top of an expression,--- returning the ticks-stripTicksTopT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]-stripTicksTopT p = go []-  where go ts (Tick t e) | p t = go (t:ts) e-        go ts _                = ts---- | Completely strip ticks satisfying a predicate from an--- expression. Note this is O(n) in the size of the expression!-stripTicksE :: (Tickish Id -> Bool) -> Expr b -> Expr b-stripTicksE p expr = go expr-  where go (App e a)        = App (go e) (go a)-        go (Lam b e)        = Lam b (go e)-        go (Let b e)        = Let (go_bs b) (go e)-        go (Case e b t as)  = Case (go e) b t (map go_a as)-        go (Cast e c)       = Cast (go e) c-        go (Tick t e)-          | p t             = go e-          | otherwise       = Tick t (go e)-        go other            = other-        go_bs (NonRec b e)  = NonRec b (go e)-        go_bs (Rec bs)      = Rec (map go_b bs)-        go_b (b, e)         = (b, go e)-        go_a (c,bs,e)       = (c,bs, go e)--stripTicksT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]-stripTicksT p expr = fromOL $ go expr-  where go (App e a)        = go e `appOL` go a-        go (Lam _ e)        = go e-        go (Let b e)        = go_bs b `appOL` go e-        go (Case e _ _ as)  = go e `appOL` concatOL (map go_a as)-        go (Cast e _)       = go e-        go (Tick t e)-          | p t             = t `consOL` go e-          | otherwise       = go e-        go _                = nilOL-        go_bs (NonRec _ e)  = go e-        go_bs (Rec bs)      = concatOL (map go_b bs)-        go_b (_, e)         = go e-        go_a (_, _, e)      = go e--{--************************************************************************-*                                                                      *-\subsection{Other expression construction}-*                                                                      *-************************************************************************--}--bindNonRec :: Id -> CoreExpr -> CoreExpr -> CoreExpr--- ^ @bindNonRec x r b@ produces either:------ > let x = r in b------ or:------ > case r of x { _DEFAULT_ -> b }------ depending on whether we have to use a @case@ or @let@--- binding for the expression (see 'needsCaseBinding').--- It's used by the desugarer to avoid building bindings--- that give Core Lint a heart attack, although actually--- the simplifier deals with them perfectly well. See--- also 'MkCore.mkCoreLet'-bindNonRec bndr rhs body-  | isTyVar bndr                       = let_bind-  | isCoVar bndr                       = if isCoArg rhs then let_bind-    {- See Note [Binding coercions] -}                  else case_bind-  | isJoinId bndr                      = let_bind-  | needsCaseBinding (idType bndr) rhs = case_bind-  | otherwise                          = let_bind-  where-    case_bind = mkDefaultCase rhs bndr body-    let_bind  = Let (NonRec bndr rhs) body---- | Tests whether we have to use a @case@ rather than @let@ binding for this expression--- as per the invariants of 'CoreExpr': see "CoreSyn#let_app_invariant"-needsCaseBinding :: Type -> CoreExpr -> Bool-needsCaseBinding ty rhs = isUnliftedType ty && not (exprOkForSpeculation rhs)-        -- Make a case expression instead of a let-        -- These can arise either from the desugarer,-        -- or from beta reductions: (\x.e) (x +# y)--mkAltExpr :: AltCon     -- ^ Case alternative constructor-          -> [CoreBndr] -- ^ Things bound by the pattern match-          -> [Type]     -- ^ The type arguments to the case alternative-          -> CoreExpr--- ^ This guy constructs the value that the scrutinee must have--- given that you are in one particular branch of a case-mkAltExpr (DataAlt con) args inst_tys-  = mkConApp con (map Type inst_tys ++ varsToCoreExprs args)-mkAltExpr (LitAlt lit) [] []-  = Lit lit-mkAltExpr (LitAlt _) _ _ = panic "mkAltExpr LitAlt"-mkAltExpr DEFAULT _ _ = panic "mkAltExpr DEFAULT"--mkDefaultCase :: CoreExpr -> Id -> CoreExpr -> CoreExpr--- Make (case x of y { DEFAULT -> e }-mkDefaultCase scrut case_bndr body-  = Case scrut case_bndr (exprType body) [(DEFAULT, [], body)]--mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr--- Use this function if possible, when building a case,--- because it ensures that the type on the Case itself--- doesn't mention variables bound by the case--- See Note [Care with the type of a case expression]-mkSingleAltCase scrut case_bndr con bndrs body-  = Case scrut case_bndr case_ty [(con,bndrs,body)]-  where-    body_ty = exprType body--    case_ty -- See Note [Care with the type of a case expression]-      | Just body_ty' <- occCheckExpand bndrs body_ty-      = body_ty'--      | otherwise-      = pprPanic "mkSingleAltCase" (ppr scrut $$ ppr bndrs $$ ppr body_ty)--{- Note [Care with the type of a case expression]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider a phantom type synonym-   type S a = Int-and we want to form the case expression-   case x of K (a::*) -> (e :: S a)--We must not make the type field of the case-expression (S a) because-'a' isn't in scope.  Hence the call to occCheckExpand.  This caused-issue #17056.--NB: this situation can only arise with type synonyms, which can-falsely "mention" type variables that aren't "really there", and which-can be eliminated by expanding the synonym.--Note [Binding coercions]-~~~~~~~~~~~~~~~~~~~~~~~~-Consider binding a CoVar, c = e.  Then, we must satisfy-Note [CoreSyn type and coercion invariant] in CoreSyn,-which allows only (Coercion co) on the RHS.--************************************************************************-*                                                                      *-               Operations oer case alternatives-*                                                                      *-************************************************************************--The default alternative must be first, if it exists at all.-This makes it easy to find, though it makes matching marginally harder.--}---- | Extract the default case alternative-findDefault :: [(AltCon, [a], b)] -> ([(AltCon, [a], b)], Maybe b)-findDefault ((DEFAULT,args,rhs) : alts) = ASSERT( null args ) (alts, Just rhs)-findDefault alts                        =                     (alts, Nothing)--addDefault :: [(AltCon, [a], b)] -> Maybe b -> [(AltCon, [a], b)]-addDefault alts Nothing    = alts-addDefault alts (Just rhs) = (DEFAULT, [], rhs) : alts--isDefaultAlt :: (AltCon, a, b) -> Bool-isDefaultAlt (DEFAULT, _, _) = True-isDefaultAlt _               = False---- | Find the case alternative corresponding to a particular--- constructor: panics if no such constructor exists-findAlt :: AltCon -> [(AltCon, a, b)] -> Maybe (AltCon, a, b)-    -- A "Nothing" result *is* legitimate-    -- See Note [Unreachable code]-findAlt con alts-  = case alts of-        (deflt@(DEFAULT,_,_):alts) -> go alts (Just deflt)-        _                          -> go alts Nothing-  where-    go []                     deflt = deflt-    go (alt@(con1,_,_) : alts) deflt-      = case con `cmpAltCon` con1 of-          LT -> deflt   -- Missed it already; the alts are in increasing order-          EQ -> Just alt-          GT -> ASSERT( not (con1 == DEFAULT) ) go alts deflt--{- Note [Unreachable code]-~~~~~~~~~~~~~~~~~~~~~~~~~~-It is possible (although unusual) for GHC to find a case expression-that cannot match.  For example:--     data Col = Red | Green | Blue-     x = Red-     f v = case x of-              Red -> ...-              _ -> ...(case x of { Green -> e1; Blue -> e2 })...--Suppose that for some silly reason, x isn't substituted in the case-expression.  (Perhaps there's a NOINLINE on it, or profiling SCC stuff-gets in the way; cf #3118.)  Then the full-laziness pass might produce-this--     x = Red-     lvl = case x of { Green -> e1; Blue -> e2 })-     f v = case x of-             Red -> ...-             _ -> ...lvl...--Now if x gets inlined, we won't be able to find a matching alternative-for 'Red'.  That's because 'lvl' is unreachable.  So rather than crashing-we generate (error "Inaccessible alternative").--Similar things can happen (augmented by GADTs) when the Simplifier-filters down the matching alternatives in Simplify.rebuildCase.--}------------------------------------mergeAlts :: [(AltCon, a, b)] -> [(AltCon, a, b)] -> [(AltCon, a, b)]--- ^ Merge alternatives preserving order; alternatives in--- the first argument shadow ones in the second-mergeAlts [] as2 = as2-mergeAlts as1 [] = as1-mergeAlts (a1:as1) (a2:as2)-  = case a1 `cmpAlt` a2 of-        LT -> a1 : mergeAlts as1      (a2:as2)-        EQ -> a1 : mergeAlts as1      as2       -- Discard a2-        GT -> a2 : mergeAlts (a1:as1) as2-------------------------------------trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]--- ^ Given:------ > case (C a b x y) of--- >        C b x y -> ...------ We want to drop the leading type argument of the scrutinee--- leaving the arguments to match against the pattern--trimConArgs DEFAULT      args = ASSERT( null args ) []-trimConArgs (LitAlt _)   args = ASSERT( null args ) []-trimConArgs (DataAlt dc) args = dropList (dataConUnivTyVars dc) args--filterAlts :: TyCon                -- ^ Type constructor of scrutinee's type (used to prune possibilities)-           -> [Type]               -- ^ And its type arguments-           -> [AltCon]             -- ^ 'imposs_cons': constructors known to be impossible due to the form of the scrutinee-           -> [(AltCon, [Var], a)] -- ^ Alternatives-           -> ([AltCon], [(AltCon, [Var], a)])-             -- Returns:-             --  1. Constructors that will never be encountered by the-             --     *default* case (if any).  A superset of imposs_cons-             --  2. The new alternatives, trimmed by-             --        a) remove imposs_cons-             --        b) remove constructors which can't match because of GADTs-             ---             -- NB: the final list of alternatives may be empty:-             -- This is a tricky corner case.  If the data type has no constructors,-             -- which GHC allows, or if the imposs_cons covers all constructors (after taking-             -- account of GADTs), then no alternatives can match.-             ---             -- If callers need to preserve the invariant that there is always at least one branch-             -- in a "case" statement then they will need to manually add a dummy case branch that just-             -- calls "error" or similar.-filterAlts _tycon inst_tys imposs_cons alts-  = (imposs_deflt_cons, addDefault trimmed_alts maybe_deflt)-  where-    (alts_wo_default, maybe_deflt) = findDefault alts-    alt_cons = [con | (con,_,_) <- alts_wo_default]--    trimmed_alts = filterOut (impossible_alt inst_tys) alts_wo_default--    imposs_cons_set = Set.fromList imposs_cons-    imposs_deflt_cons =-      imposs_cons ++ filterOut (`Set.member` imposs_cons_set) alt_cons-         -- "imposs_deflt_cons" are handled-         --   EITHER by the context,-         --   OR by a non-DEFAULT branch in this case expression.--    impossible_alt :: [Type] -> (AltCon, a, b) -> Bool-    impossible_alt _ (con, _, _) | con `Set.member` imposs_cons_set = True-    impossible_alt inst_tys (DataAlt con, _, _) = dataConCannotMatch inst_tys con-    impossible_alt _  _                         = False---- | Refine the default alternative to a 'DataAlt', if there is a unique way to do so.--- See Note [Refine Default Alts]-refineDefaultAlt :: [Unique]          -- ^ Uniques for constructing new binders-                 -> TyCon             -- ^ Type constructor of scrutinee's type-                 -> [Type]            -- ^ Type arguments of scrutinee's type-                 -> [AltCon]          -- ^ Constructors that cannot match the DEFAULT (if any)-                 -> [CoreAlt]-                 -> (Bool, [CoreAlt]) -- ^ 'True', if a default alt was replaced with a 'DataAlt'-refineDefaultAlt us tycon tys imposs_deflt_cons all_alts-  | (DEFAULT,_,rhs) : rest_alts <- all_alts-  , isAlgTyCon tycon            -- It's a data type, tuple, or unboxed tuples.-  , not (isNewTyCon tycon)      -- We can have a newtype, if we are just doing an eval:-                                --      case x of { DEFAULT -> e }-                                -- and we don't want to fill in a default for them!-  , Just all_cons <- tyConDataCons_maybe tycon-  , let imposs_data_cons = mkUniqSet [con | DataAlt con <- imposs_deflt_cons]-                             -- We now know it's a data type, so we can use-                             -- UniqSet rather than Set (more efficient)-        impossible con   = con `elementOfUniqSet` imposs_data_cons-                             || dataConCannotMatch tys con-  = case filterOut impossible all_cons of-       -- Eliminate the default alternative-       -- altogether if it can't match:-       []    -> (False, rest_alts)--       -- It matches exactly one constructor, so fill it in:-       [con] -> (True, mergeAlts rest_alts [(DataAlt con, ex_tvs ++ arg_ids, rhs)])-                       -- We need the mergeAlts to keep the alternatives in the right order-             where-                (ex_tvs, arg_ids) = dataConRepInstPat us con tys--       -- It matches more than one, so do nothing-       _  -> (False, all_alts)--  | debugIsOn, isAlgTyCon tycon, null (tyConDataCons tycon)-  , not (isFamilyTyCon tycon || isAbstractTyCon tycon)-        -- Check for no data constructors-        -- This can legitimately happen for abstract types and type families,-        -- so don't report that-  = (False, all_alts)--  | otherwise      -- The common case-  = (False, all_alts)--{- Note [Refine Default Alts]--refineDefaultAlt replaces the DEFAULT alt with a constructor if there is one-possible value it could be.--The simplest example being--foo :: () -> ()-foo x = case x of !_ -> ()--rewrites to--foo :: () -> ()-foo x = case x of () -> ()--There are two reasons in general why this is desirable.--1. We can simplify inner expressions--In this example we can eliminate the inner case by refining the outer case.-If we don't refine it, we are left with both case expressions.--```-{-# LANGUAGE BangPatterns #-}-module Test where--mid x = x-{-# NOINLINE mid #-}--data Foo = Foo1 ()--test :: Foo -> ()-test x =-  case x of-    !_ -> mid (case x of-                Foo1 x1 -> x1)--```--refineDefaultAlt fills in the DEFAULT here with `Foo ip1` and then x-becomes bound to `Foo ip1` so is inlined into the other case which-causes the KnownBranch optimisation to kick in.---2. combineIdenticalAlts does a better job--Simon Jakobi also points out that that combineIdenticalAlts will do a better job-if we refine the DEFAULT first.--```-data D = C0 | C1 | C2--case e of-   DEFAULT -> e0-   C0 -> e1-   C1 -> e1-```--When we apply combineIdenticalAlts to this expression, it can't-combine the alts for C0 and C1, as we already have a default case.--If we apply refineDefaultAlt first, we get--```-case e of-  C0 -> e1-  C1 -> e1-  C2 -> e0-```--and combineIdenticalAlts can turn that into--```-case e of-  DEFAULT -> e1-  C2 -> e0-```--It isn't obvious that refineDefaultAlt does this but if you look at its one-call site in SimplUtils then the `imposs_deflt_cons` argument is populated with-constructors which are matched elsewhere.---}-----{- Note [Combine identical alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If several alternatives are identical, merge them into a single-DEFAULT alternative.  I've occasionally seen this making a big-difference:--     case e of               =====>     case e of-       C _ -> f x                         D v -> ....v....-       D v -> ....v....                   DEFAULT -> f x-       DEFAULT -> f x--The point is that we merge common RHSs, at least for the DEFAULT case.-[One could do something more elaborate but I've never seen it needed.]-To avoid an expensive test, we just merge branches equal to the *first*-alternative; this picks up the common cases-     a) all branches equal-     b) some branches equal to the DEFAULT (which occurs first)--The case where Combine Identical Alternatives transformation showed up-was like this (base/Foreign/C/Err/Error.hs):--        x | p `is` 1 -> e1-          | p `is` 2 -> e2-        ...etc...--where @is@ was something like--        p `is` n = p /= (-1) && p == n--This gave rise to a horrible sequence of cases--        case p of-          (-1) -> $j p-          1    -> e1-          DEFAULT -> $j p--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 Simplify.simplAlt may zap the-occurrence info on the binders in the alternatives, which in turn-defeats combineIdenticalAlts (see #7360).--Note [Care with impossible-constructors when combining alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose we have (#10538)-   data T = A | B | C | D--      case x::T of   (Imposs-default-cons {A,B})-         DEFAULT -> e1-         A -> e2-         B -> e1--When calling combineIdentialAlts, we'll have computed that the-"impossible constructors" for the DEFAULT alt is {A,B}, since if x is-A or B we'll take the other alternatives.  But suppose we combine B-into the DEFAULT, to get--      case x::T of   (Imposs-default-cons {A})-         DEFAULT -> e1-         A -> e2--Then we must be careful to trim the impossible constructors to just {A},-else we risk compiling 'e1' wrong!--Not only that, but we take care when there is no DEFAULT beforehand,-because we are introducing one.  Consider--   case x of   (Imposs-default-cons {A,B,C})-     A -> e1-     B -> e2-     C -> e1--Then when combining the A and C alternatives we get--   case x of   (Imposs-default-cons {B})-     DEFAULT -> e1-     B -> e2--Note that we have a new DEFAULT branch that we didn't have before.  So-we need delete from the "impossible-default-constructors" all the-known-con alternatives that we have eliminated. (In #11172 we-missed the first one.)---}--combineIdenticalAlts :: [AltCon]    -- Constructors that cannot match DEFAULT-                     -> [CoreAlt]-                     -> (Bool,      -- True <=> something happened-                         [AltCon],  -- New constructors that cannot match DEFAULT-                         [CoreAlt]) -- New alternatives--- See Note [Combine identical alternatives]--- True <=> we did some combining, result is a single DEFAULT alternative-combineIdenticalAlts imposs_deflt_cons ((con1,bndrs1,rhs1) : rest_alts)-  | all isDeadBinder bndrs1    -- Remember the default-  , not (null elim_rest) -- alternative comes first-  = (True, imposs_deflt_cons', deflt_alt : filtered_rest)-  where-    (elim_rest, filtered_rest) = partition identical_to_alt1 rest_alts-    deflt_alt = (DEFAULT, [], mkTicks (concat tickss) rhs1)--     -- See Note [Care with impossible-constructors when combining alternatives]-    imposs_deflt_cons' = imposs_deflt_cons `minusList` elim_cons-    elim_cons = elim_con1 ++ map fstOf3 elim_rest-    elim_con1 = case con1 of     -- Don't forget con1!-                  DEFAULT -> []  -- See Note [-                  _       -> [con1]--    cheapEqTicked e1 e2 = cheapEqExpr' tickishFloatable e1 e2-    identical_to_alt1 (_con,bndrs,rhs)-      = all isDeadBinder bndrs && rhs `cheapEqTicked` rhs1-    tickss = map (stripTicksT tickishFloatable . thdOf3) elim_rest--combineIdenticalAlts imposs_cons alts-  = (False, imposs_cons, alts)--{- *********************************************************************-*                                                                      *-             exprIsTrivial-*                                                                      *-************************************************************************--Note [exprIsTrivial]-~~~~~~~~~~~~~~~~~~~~-@exprIsTrivial@ is true of expressions we are unconditionally happy to-                duplicate; simple variables and constants, and type-                applications.  Note that primop Ids aren't considered-                trivial unless--Note [Variables are trivial]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-There used to be a gruesome test for (hasNoBinding v) in the-Var case:-        exprIsTrivial (Var v) | hasNoBinding v = idArity v == 0-The idea here is that a constructor worker, like \$wJust, is-really short for (\x -> \$wJust x), because \$wJust has no binding.-So it should be treated like a lambda.  Ditto unsaturated primops.-But now constructor workers are not "have-no-binding" Ids.  And-completely un-applied primops and foreign-call Ids are sufficiently-rare that I plan to allow them to be duplicated and put up with-saturating them.--Note [Tick trivial]-~~~~~~~~~~~~~~~~~~~-Ticks are only trivial if they are pure annotations. If we treat-"tick<n> x" as trivial, it will be inlined inside lambdas and the-entry count will be skewed, for example.  Furthermore "scc<n> x" will-turn into just "x" in mkTick.--Note [Empty case is trivial]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The expression (case (x::Int) Bool of {}) is just a type-changing-case used when we are sure that 'x' will not return.  See-Note [Empty case alternatives] in CoreSyn.--If the scrutinee is trivial, then so is the whole expression; and the-CoreToSTG pass in fact drops the case expression leaving only the-scrutinee.--Having more trivial expressions is good.  Moreover, if we don't treat-it as trivial we may land up with let-bindings like-   let v = case x of {} in ...-and after CoreToSTG that gives-   let v = x in ...-and that confuses the code generator (#11155). So best to kill-it off at source.--}--exprIsTrivial :: CoreExpr -> Bool--- If you modify this function, you may also--- need to modify getIdFromTrivialExpr-exprIsTrivial (Var _)          = True        -- See Note [Variables are trivial]-exprIsTrivial (Type _)         = True-exprIsTrivial (Coercion _)     = True-exprIsTrivial (Lit lit)        = litIsTrivial lit-exprIsTrivial (App e arg)      = not (isRuntimeArg arg) && exprIsTrivial e-exprIsTrivial (Lam b e)        = not (isRuntimeVar b) && exprIsTrivial e-exprIsTrivial (Tick t e)       = not (tickishIsCode t) && exprIsTrivial e-                                 -- See Note [Tick trivial]-exprIsTrivial (Cast e _)       = exprIsTrivial e-exprIsTrivial (Case e _ _ [])  = exprIsTrivial e  -- See Note [Empty case is trivial]-exprIsTrivial _                = False--{--Note [getIdFromTrivialExpr]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-When substituting in a breakpoint we need to strip away the type cruft-from a trivial expression and get back to the Id.  The invariant is-that the expression we're substituting was originally trivial-according to exprIsTrivial, AND the expression is not a literal.-See Note [substTickish] for how breakpoint substitution preserves-this extra invariant.--We also need this functionality in CorePrep to extract out Id of a-function which we are saturating.  However, in this case we don't know-if the variable actually refers to a literal; thus we use-'getIdFromTrivialExpr_maybe' to handle this case.  See test-T12076lit for an example where this matters.--}--getIdFromTrivialExpr :: HasDebugCallStack => CoreExpr -> Id-getIdFromTrivialExpr e-    = fromMaybe (pprPanic "getIdFromTrivialExpr" (ppr e))-                (getIdFromTrivialExpr_maybe e)--getIdFromTrivialExpr_maybe :: CoreExpr -> Maybe Id--- See Note [getIdFromTrivialExpr]--- Th equations for this should line up with those for exprIsTrivial-getIdFromTrivialExpr_maybe e-  = go e-  where-    go (App f t) | not (isRuntimeArg t)   = go f-    go (Tick t e) | not (tickishIsCode t) = go e-    go (Cast e _)                         = go e-    go (Lam b e) | not (isRuntimeVar b)   = go e-    go (Case e _ _ [])                    = go e-    go (Var v) = Just v-    go _       = Nothing--{--exprIsBottom is a very cheap and cheerful function; it may return-False for bottoming expressions, but it never costs much to ask.  See-also CoreArity.exprBotStrictness_maybe, but that's a bit more-expensive.--}--exprIsBottom :: CoreExpr -> Bool--- See Note [Bottoming expressions]-exprIsBottom e-  | isEmptyTy (exprType e)-  = True-  | otherwise-  = go 0 e-  where-    go n (Var v) = isBottomingId v &&  n >= idArity v-    go n (App e a) | isTypeArg a = go n e-                   | otherwise   = go (n+1) e-    go n (Tick _ e)              = go n e-    go n (Cast e _)              = go n e-    go n (Let _ e)               = go n e-    go n (Lam v e) | isTyVar v   = go n e-    go _ (Case _ _ _ alts)       = null alts-       -- See Note [Empty case alternatives] in CoreSyn-    go _ _                       = False--{- Note [Bottoming expressions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A bottoming expression is guaranteed to diverge, or raise an-exception.  We can test for it in two different ways, and exprIsBottom-checks for both of these situations:--* Visibly-bottom computations.  For example-      (error Int "Hello")-  is visibly bottom.  The strictness analyser also finds out if-  a function diverges or raises an exception, and puts that info-  in its strictness signature.--* Empty types.  If a type is empty, its only inhabitant is bottom.-  For example:-      data T-      f :: T -> Bool-      f = \(x:t). case x of Bool {}-  Since T has no data constructors, the case alternatives are of course-  empty.  However note that 'x' is not bound to a visibly-bottom value;-  it's the *type* that tells us it's going to diverge.--A GADT may also be empty even though it has constructors:-        data T a where-          T1 :: a -> T Bool-          T2 :: T Int-        ...(case (x::T Char) of {})...-Here (T Char) is uninhabited.  A more realistic case is (Int ~ Bool),-which is likewise uninhabited.---************************************************************************-*                                                                      *-             exprIsDupable-*                                                                      *-************************************************************************--Note [exprIsDupable]-~~~~~~~~~~~~~~~~~~~~-@exprIsDupable@ is true of expressions that can be duplicated at a modest-                cost in code size.  This will only happen in different case-                branches, so there's no issue about duplicating work.--                That is, exprIsDupable returns True of (f x) even if-                f is very very expensive to call.--                Its only purpose is to avoid fruitless let-binding-                and then inlining of case join points--}--exprIsDupable :: DynFlags -> CoreExpr -> Bool-exprIsDupable dflags e-  = isJust (go dupAppSize e)-  where-    go :: Int -> CoreExpr -> Maybe Int-    go n (Type {})     = Just n-    go n (Coercion {}) = Just n-    go n (Var {})      = decrement n-    go n (Tick _ e)    = go n e-    go n (Cast e _)    = go n e-    go n (App f a) | Just n' <- go n a = go n' f-    go n (Lit lit) | litIsDupable dflags lit = decrement n-    go _ _ = Nothing--    decrement :: Int -> Maybe Int-    decrement 0 = Nothing-    decrement n = Just (n-1)--dupAppSize :: Int-dupAppSize = 8   -- Size of term we are prepared to duplicate-                 -- This is *just* big enough to make test MethSharing-                 -- inline enough join points.  Really it should be-                 -- smaller, and could be if we fixed #4960.--{--************************************************************************-*                                                                      *-             exprIsCheap, exprIsExpandable-*                                                                      *-************************************************************************--Note [exprIsWorkFree]-~~~~~~~~~~~~~~~~~~~~~-exprIsWorkFree is used when deciding whether to inline something; we-don't inline it if doing so might duplicate work, by peeling off a-complete copy of the expression.  Here we do not want even to-duplicate a primop (#5623):-   eg   let x = a #+ b in x +# x-   we do not want to inline/duplicate x--Previously we were a bit more liberal, which led to the primop-duplicating-problem.  However, being more conservative did lead to a big regression in-one nofib benchmark, wheel-sieve1.  The situation looks like this:--   let noFactor_sZ3 :: GHC.Types.Int -> GHC.Types.Bool-       noFactor_sZ3 = case s_adJ of _ { GHC.Types.I# x_aRs ->-         case GHC.Prim.<=# x_aRs 2 of _ {-           GHC.Types.False -> notDivBy ps_adM qs_adN;-           GHC.Types.True -> lvl_r2Eb }}-       go = \x. ...(noFactor (I# y))....(go x')...--The function 'noFactor' is heap-allocated and then called.  Turns out-that 'notDivBy' is strict in its THIRD arg, but that is invisible to-the caller of noFactor, which therefore cannot do w/w and-heap-allocates noFactor's argument.  At the moment (May 12) we are just-going to put up with this, because the previous more aggressive inlining-(which treated 'noFactor' as work-free) was duplicating primops, which-in turn was making inner loops of array calculations runs slow (#5623)--Note [Case expressions are work-free]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Are case-expressions work-free?  Consider-    let v = case x of (p,q) -> p-        go = \y -> ...case v of ...-Should we inline 'v' at its use site inside the loop?  At the moment-we do.  I experimented with saying that case are *not* work-free, but-that increased allocation slightly.  It's a fairly small effect, and at-the moment we go for the slightly more aggressive version which treats-(case x of ....) as work-free if the alternatives are.--Moreover it improves arities of overloaded functions where-there is only dictionary selection (no construction) involved--Note [exprIsCheap]   See also Note [Interaction of exprIsCheap and lone variables]-~~~~~~~~~~~~~~~~~~   in CoreUnfold.hs-@exprIsCheap@ looks at a Core expression and returns \tr{True} if-it is obviously in weak head normal form, or is cheap to get to WHNF.-[Note that that's not the same as exprIsDupable; an expression might be-big, and hence not dupable, but still cheap.]--By ``cheap'' we mean a computation we're willing to:-        push inside a lambda, or-        inline at more than one place-That might mean it gets evaluated more than once, instead of being-shared.  The main examples of things which aren't WHNF but are-``cheap'' are:--  *     case e of-          pi -> ei-        (where e, and all the ei are cheap)--  *     let x = e in b-        (where e and b are cheap)--  *     op x1 ... xn-        (where op is a cheap primitive operator)--  *     error "foo"-        (because we are happy to substitute it inside a lambda)--Notice that a variable is considered 'cheap': we can push it inside a lambda,-because sharing will make sure it is only evaluated once.--Note [exprIsCheap and exprIsHNF]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Note that exprIsHNF does not imply exprIsCheap.  Eg-        let x = fac 20 in Just x-This responds True to exprIsHNF (you can discard a seq), but-False to exprIsCheap.--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 = blah in f x-should behave equivalently to-   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--}-----------------------exprIsWorkFree :: CoreExpr -> Bool   -- See Note [exprIsWorkFree]-exprIsWorkFree = exprIsCheapX isWorkFreeApp--exprIsCheap :: CoreExpr -> Bool-exprIsCheap = exprIsCheapX isCheapApp--exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool-exprIsCheapX ok_app e-  = ok e-  where-    ok e = go 0 e--    -- n is the number of value arguments-    go n (Var v)                      = ok_app v n-    go _ (Lit {})                     = True-    go _ (Type {})                    = True-    go _ (Coercion {})                = True-    go n (Cast e _)                   = go n e-    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 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, Let: see Note [Arguments and let-bindings exprIsCheapX]---{- Note [exprIsExpandable]-~~~~~~~~~~~~~~~~~~~~~~~~~~-An expression is "expandable" if we are willing to duplicate it, if doing-so might make a RULE or case-of-constructor fire.  Consider-   let x = (a,b)-       y = build g-   in ....(case x of (p,q) -> rhs)....(foldr k z y)....--We don't inline 'x' or 'y' (see Note [Lone variables] in CoreUnfold),-but we do want-- * the case-expression to simplify-   (via exprIsConApp_maybe, exprIsLiteral_maybe)-- * the foldr/build RULE to fire-   (by expanding the unfolding during rule matching)--So we classify the unfolding of a let-binding as "expandable" (via the-uf_expandable field) if we want to do this kind of on-the-fly-expansion.  Specifically:--* True of constructor applications (K a b)--* True of applications of a "CONLIKE" Id; see Note [CONLIKE pragma] in BasicTypes.-  (NB: exprIsCheap might not be true of this)--* False of case-expressions.  If we have-    let x = case ... in ...(case x of ...)...-  we won't simplify.  We have to inline x.  See #14688.--* False of let-expressions (same reason); and in any case we-  float lets out of an RHS if doing so will reveal an expandable-  application (see SimplEnv.doFloatFromRhs).--* Take care: exprIsExpandable should /not/ be true of primops.  I-  found this in test T5623a:-    let q = /\a. Ptr a (a +# b)-    in case q @ Float of Ptr v -> ...q...--  q's inlining should not be expandable, else exprIsConApp_maybe will-  say that (q @ Float) expands to (Ptr a (a +# b)), and that will-  duplicate the (a +# b) primop, which we should not do lightly.-  (It's quite hard to trigger this bug, but T13155 does so for GHC 8.0.)--}----------------------------------------exprIsExpandable :: CoreExpr -> Bool--- See Note [exprIsExpandable]-exprIsExpandable e-  = ok e-  where-    ok e = go 0 e--    -- n is the number of value arguments-    go n (Var v)                      = isExpandableApp v n-    go _ (Lit {})                     = True-    go _ (Type {})                    = True-    go _ (Coercion {})                = True-    go n (Cast e _)                   = go n e-    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 _ (Case {})                    = False-    go _ (Let {})                     = False-----------------------------------------type CheapAppFun = Id -> Arity -> Bool-  -- Is an application of this function to n *value* args-  -- always cheap, assuming the arguments are cheap?-  -- True mainly of data constructors, partial applications;-  -- but with minor variations:-  --    isWorkFreeApp-  --    isCheapApp-  --    isExpandableApp--isWorkFreeApp :: CheapAppFun-isWorkFreeApp 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-      _                -> False--isCheapApp :: CheapAppFun-isCheapApp fn n_val_args-  | isWorkFreeApp fn n_val_args = True-  | isBottomingId fn            = True  -- See Note [isCheapApp: bottoming functions]-  | otherwise-  = case idDetails fn of-      DataConWorkId {} -> True  -- Actually handled by isWorkFreeApp-      RecSelId {}      -> n_val_args == 1  -- See Note [Record selection]-      ClassOpId {}     -> n_val_args == 1-      PrimOpId op      -> primOpIsCheap op-      _                -> False-        -- In principle we should worry about primops-        -- that return a type variable, since the result-        -- might be applied to something, but I'm not going-        -- to bother to check the number of args--isExpandableApp :: CheapAppFun-isExpandableApp fn n_val_args-  | isWorkFreeApp fn n_val_args = True-  | otherwise-  = case idDetails fn of-      DataConWorkId {} -> True  -- Actually handled by isWorkFreeApp-      RecSelId {}      -> n_val_args == 1  -- See Note [Record selection]-      ClassOpId {}     -> n_val_args == 1-      PrimOpId {}      -> False-      _ | 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]-     all_args_are_preds = all_pred_args n_val_args (idType fn)--     all_pred_args n_val_args ty-       | n_val_args == 0-       = True--       | Just (bndr, ty) <- splitPiTy_maybe ty-       = case bndr of-           Named {}        -> all_pred_args n_val_args ty-           Anon InvisArg _ -> all_pred_args (n_val_args-1) ty-           Anon VisArg _   -> False--       | otherwise-       = False--{- 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-lambda.  Particularly for dictionary field selection.--BUT: Take care with (sel d x)!  The (sel d) might be cheap, but-there's no guarantee that (sel d x) will be too.  Hence (n_val_args == 1)--Note [Expandable overloadings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose the user wrote this-   {-# RULE  forall x. foo (negate x) = h x #-}-   f x = ....(foo (negate x))....-He'd expect the rule to fire. But since negate is overloaded, we might-get this:-    f = \d -> let n = negate d in \x -> ...foo (n x)...-So we treat the application of a function (negate in this case) to a-*dictionary* as expandable.  In effect, every function is CONLIKE when-it's applied only to dictionaries.---************************************************************************-*                                                                      *-             exprOkForSpeculation-*                                                                      *-************************************************************************--}---------------------------------- | 'exprOkForSpeculation' returns True of an expression that is:------  * Safe to evaluate even if normal order eval might not---    evaluate the expression at all, or------  * Safe /not/ to evaluate even if normal order would do so------ It is usually called on arguments of unlifted type, but not always--- In particular, Simplify.rebuildCase calls it on lifted types--- when a 'case' is a plain 'seq'. See the example in--- Note [exprOkForSpeculation: case expressions] below------ Precisely, it returns @True@ iff:---  a) The expression guarantees to terminate,---  b) soon,---  c) without causing a write side effect (e.g. writing a mutable variable)---  d) without throwing a Haskell exception---  e) without risking an unchecked runtime exception (array out of bounds,---     divide by zero)------ For @exprOkForSideEffects@ the list is the same, but omitting (e).------ Note that---    exprIsHNF            implies exprOkForSpeculation---    exprOkForSpeculation implies exprOkForSideEffects------ See Note [PrimOp can_fail and has_side_effects] in PrimOp--- and Note [Transformations affected by can_fail and has_side_effects]------ As an example of the considerations in this test, consider:------ > let x = case y# +# 1# of { r# -> I# r# }--- > in E------ being translated to:------ > case y# +# 1# of { r# ->--- >    let x = I# r#--- >    in E--- > }------ 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--expr_ok :: (PrimOp -> Bool) -> CoreExpr -> Bool-expr_ok _ (Lit _)      = True-expr_ok _ (Type _)     = True-expr_ok _ (Coercion _) = True--expr_ok primop_ok (Var v)    = app_ok primop_ok v []-expr_ok primop_ok (Cast e _) = expr_ok primop_ok e-expr_ok primop_ok (Lam b e)-                 | isTyVar b = expr_ok primop_ok  e-                 | otherwise = True---- Tick annotations that *tick* cannot be speculated, because these--- are meant to identify whether or not (and how often) the particular--- source expression was evaluated at runtime.-expr_ok primop_ok (Tick tickish e)-   | tickishCounts tickish = False-   | otherwise             = expr_ok primop_ok e--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--expr_ok primop_ok other_expr-  | (expr, args) <- collectArgs other_expr-  = case stripTicksTopE (not . tickishCounts) expr of-        Var f   -> app_ok primop_ok f args-        -- 'LitRubbish' is the only literal that can occur in the head of an-        -- application and will not be matched by the above case (Var /= Lit).-        Lit lit -> ASSERT( lit == rubbishLit ) True-        _       -> False--------------------------------app_ok :: (PrimOp -> Bool) -> Id -> [CoreExpr] -> Bool-app_ok primop_ok fun args-  = case idDetails fun of-      DFunId new_type ->  not new_type-         -- DFuns terminate, unless the dict is implemented-         -- with a newtype in which case they may not--      DataConWorkId {} -> True-                -- The strictness of the constructor has already-                -- been expressed by its "wrapper", so we don't need-                -- to take the arguments into account--      PrimOpId op-        | isDivOp op-        , [arg1, Lit lit] <- args-        -> not (isZeroLit lit) && expr_ok primop_ok arg1-              -- Special case for dividing operations that fail-              -- In general they are NOT ok-for-speculation-              -- (which primop_ok will catch), but they ARE OK-              -- if the divisor is definitely non-zero.-              -- Often there is a literal divisor, and this-              -- can get rid of a thunk in an inner loop--        | SeqOp <- op  -- See Note [exprOkForSpeculation and SeqOp/DataToTagOp]-        -> False       --     for the special cases for SeqOp and DataToTagOp-        | DataToTagOp <- op-        -> False--        | otherwise-        -> primop_ok op  -- Check the primop itself-        && and (zipWith primop_arg_ok arg_tys args)  -- Check the arguments--      _other -> isUnliftedType (idType fun)          -- c.f. the Var case of exprIsHNF-             || idArity fun > n_val_args             -- Partial apps-             -- NB: even in the nullary case, do /not/ check-             --     for evaluated-ness of the fun;-             --     see Note [exprOkForSpeculation and evaluated variables]-             where-               n_val_args = valArgCount args-  where-    (arg_tys, _) = splitPiTys (idType fun)--    primop_arg_ok :: TyBinder -> CoreExpr -> Bool-    primop_arg_ok (Named _) _ = True   -- A type argument-    primop_arg_ok (Anon _ ty) arg      -- A term argument-       | isUnliftedType ty = expr_ok primop_ok arg-       | otherwise         = True  -- See Note [Primops with lifted arguments]--------------------------------altsAreExhaustive :: [Alt b] -> Bool--- True  <=> the case alternatives are definitely exhaustive--- False <=> they may or may not be-altsAreExhaustive []-  = False    -- Should not happen-altsAreExhaustive ((con1,_,_) : alts)-  = case con1 of-      DEFAULT   -> True-      LitAlt {} -> False-      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-      -- enough to deserve special treatment---- | True of dyadic operators that can fail only if the second arg is zero!-isDivOp :: PrimOp -> Bool--- This function probably belongs in PrimOp, or even in--- an automagically generated file.. but it's such a--- special case I thought I'd leave it here for now.-isDivOp IntQuotOp        = True-isDivOp IntRemOp         = True-isDivOp WordQuotOp       = True-isDivOp WordRemOp        = True-isDivOp FloatDivOp       = True-isDivOp DoubleDivOp      = True-isDivOp _                = False--{- 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 { DEFAULT -> 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.--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. for example,-  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-  evaluate 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: #15696: ---------  Previously SetLevels used exprOkForSpeculation to guide-  floating of single-alternative cases; it now uses exprIsHNF-  Note [Floating single-alternative cases].--  But in those days, consider-    case e of x { DEAFULT ->-      ...(case x of y-            A -> ...-            _ -> ...(case (case x of { B -> p; C -> p }) of-                       I# r -> blah)...-  If SetLevels considers the inner nested case as-  ok-for-speculation it can do case-floating (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 #5453.------- Historical note: #3717: ---------    foo :: Int -> Int-    foo 0 = 0-    foo n = (if n < 5 then 1 else 2) `seq` foo (n-1)--In earlier GHCs, we got this:-    T.$wfoo =-      \ (ww :: GHC.Prim.Int#) ->-        case ww of ds {-          __DEFAULT -> case (case <# ds 5 of _ {-                          GHC.Types.False -> lvl1;-                          GHC.Types.True -> lvl})-                       of _ { __DEFAULT ->-                       T.$wfoo (GHC.Prim.-# ds_XkE 1) };-          0 -> 0 }--Before join-points etc we could only get rid of two cases (which are-redundant) by recognising that the (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]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Is this ok-for-speculation (see #13027)?-   reallyUnsafePtrEq# a b-Well, yes.  The primop accepts lifted arguments and does not-evaluate them.  Indeed, in general primops are, well, primitive-and do not perform evaluation.--Bottom line:-  * In exprOkForSpeculation we simply ignore all lifted arguments.-  * In the rare case of primops that /do/ evaluate their arguments,-    (namely DataToTagOp and SeqOp) return False; see-    Note [exprOkForSpeculation and evaluated variables]--Note [exprOkForSpeculation and SeqOp/DataToTagOp]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Most primops with lifted arguments don't evaluate them-(see Note [Primops with lifted arguments]), so we can ignore-that argument entirely when doing exprOkForSpeculation.--But DataToTagOp and SeqOp are exceptions to that rule.-For reasons described in Note [exprOkForSpeculation and-evaluated variables], we simply return False for them.--Not doing this made #5129 go bad.-Lots of discussion in #15696.--Note [exprOkForSpeculation and evaluated variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Recall that-  seq#       :: forall a s. a -> State# s -> (# State# s, a #)-  dataToTag# :: forall a.   a -> Int#-must always evaluate their first argument.--Now consider these examples:- * case x of y { DEFAULT -> ....y.... }-   Should 'y' (alone) be considered ok-for-speculation?-- * case x of y { DEFAULT -> ....f (dataToTag# y)... }-   Should (dataToTag# y) be considered ok-for-spec?--You could argue 'yes', because in the case alternative we know that-'y' is evaluated.  But the binder-swap transformation, which is-extremely useful for float-out, changes these expressions to-   case x of y { DEFAULT -> ....x.... }-   case x of y { DEFAULT -> ....f (dataToTag# x)... }--And now the expression does not obey the let/app invariant!  Yikes!-Moreover we really might float (f (dataToTag# x)) outside the case,-and then it really, really doesn't obey the let/app invariant.--The solution is simple: exprOkForSpeculation does not try to take-advantage of the evaluated-ness of (lifted) variables.  And it returns-False (always) for DataToTagOp and SeqOp.--Note that exprIsHNF /can/ and does take advantage of evaluated-ness;-it doesn't have the trickiness of the let/app invariant to worry about.--************************************************************************-*                                                                      *-             exprIsHNF, exprIsConLike-*                                                                      *-************************************************************************--}---- Note [exprIsHNF]             See also Note [exprIsCheap and exprIsHNF]--- ~~~~~~~~~~~~~~~~--- | exprIsHNF returns true for expressions that are certainly /already/--- evaluated to /head/ normal form.  This is used to decide whether it's ok--- to change:------ > case x of _ -> e------    into:------ > e------ and to decide whether it's safe to discard a 'seq'.------ So, it does /not/ treat variables as evaluated, unless they say they are.--- However, it /does/ treat partial applications and constructor applications--- as values, even if their arguments are non-trivial, provided the argument--- type is lifted. For example, both of these are values:------ > (:) (f x) (map f xs)--- > map (...redex...)------ because 'seq' on such things completes immediately.------ For unlifted argument types, we have to be careful:------ > C (f x :: Int#)------ Suppose @f x@ diverges; then @C (f x)@ is not a value. However this can't--- happen: see "CoreSyn#let_app_invariant". This invariant states that arguments of--- unboxed type must be ok-for-speculation (or trivial).-exprIsHNF :: CoreExpr -> Bool           -- True => Value-lambda, constructor, PAP-exprIsHNF = exprIsHNFlike isDataConWorkId isEvaldUnfolding---- | Similar to 'exprIsHNF' but includes CONLIKE functions as well as--- data constructors. Conlike arguments are considered interesting by the--- inliner.-exprIsConLike :: CoreExpr -> Bool       -- True => lambda, conlike, PAP-exprIsConLike = exprIsHNFlike isConLikeId isConLikeUnfolding---- | Returns true for values or value-like expressions. These are lambdas,--- constructors / CONLIKE functions (as determined by the function argument)--- or PAPs.----exprIsHNFlike :: (Var -> Bool) -> (Unfolding -> Bool) -> CoreExpr -> Bool-exprIsHNFlike is_con is_con_unf = is_hnf_like-  where-    is_hnf_like (Var v) -- NB: There are no value args at this point-      =  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-        --   or to a guaranteed-evaluated variable (isEvaldUnfolding)-        --   Contrast with Note [exprOkForSpeculation and evaluated variables]-        -- We don't look through loop breakers here, which is a bit conservative-        -- but otherwise I worry that if an Id's unfolding is just itself,-        -- we could get an infinite loop--    is_hnf_like (Lit _)          = True-    is_hnf_like (Type _)         = True       -- Types are honorary Values;-                                              -- we don't mind copying them-    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-                                      -- See Note [exprIsHNF Tick]-    is_hnf_like (Cast e _)       = is_hnf_like e-    is_hnf_like (App e a)-      | isValArg a               = app_is_value e 1-      | otherwise                = is_hnf_like e-    is_hnf_like (Let _ e)        = is_hnf_like e  -- Lazy let(rec)s don't affect us-    is_hnf_like _                = False--    -- 'n' is the number of value args to which the expression is applied-    -- And n>0: there is at least one value argument-    app_is_value :: CoreExpr -> Int -> Bool-    app_is_value (Var f)    nva = id_app_is_value f nva-    app_is_value (Tick _ f) nva = app_is_value f nva-    app_is_value (Cast f _) nva = app_is_value f nva-    app_is_value (App f a)  nva-      | isValArg a              = app_is_value f (nva + 1)-      | otherwise               = app_is_value f nva-    app_is_value _          _   = False--    id_app_is_value id n_val_args-       = is_con id-       || idArity id > n_val_args-       || id `hasKey` absentErrorIdKey  -- See Note [aBSENT_ERROR_ID] in MkCore-                      -- absentError behaves like an honorary data constructor---{--Note [exprIsHNF Tick]--We can discard source annotations on HNFs as long as they aren't-tick-like:--  scc c (\x . e)    =>  \x . e-  scc c (C x1..xn)  =>  C x1..xn--So we regard these as HNFs.  Tick annotations that tick are not-regarded as HNF if the expression they surround is HNF, because the-tick is there to tell us that the expression was evaluated, so we-don't want to discard a seq on it.--}---- | Can we bind this 'CoreExpr' at the top level?-exprIsTopLevelBindable :: CoreExpr -> Type -> Bool--- See Note [CoreSyn top-level string literals]--- Precondition: exprType expr = ty--- Top-level literal strings can't even be wrapped in ticks---   see Note [CoreSyn top-level string literals] in CoreSyn-exprIsTopLevelBindable expr ty-  = not (mightBeUnliftedType ty)-    -- Note that 'expr' may be levity polymorphic here consequently we must use-    -- 'mightBeUnliftedType' rather than 'isUnliftedType' as the latter would panic.-  || exprIsTickedString expr---- | Check if the expression is zero or more Ticks wrapped around a literal--- string.-exprIsTickedString :: CoreExpr -> Bool-exprIsTickedString = isJust . exprIsTickedString_maybe---- | Extract a literal string from an expression that is zero or more Ticks--- wrapped around a literal string. Returns Nothing if the expression has a--- different shape.--- Used to "look through" Ticks in places that need to handle literal strings.-exprIsTickedString_maybe :: CoreExpr -> Maybe ByteString-exprIsTickedString_maybe (Lit (LitString bs)) = Just bs-exprIsTickedString_maybe (Tick t e)-  -- we don't tick literals with CostCentre ticks, compare to mkTick-  | tickishPlace t == PlaceCostCentre = Nothing-  | otherwise = exprIsTickedString_maybe e-exprIsTickedString_maybe _ = Nothing--{--************************************************************************-*                                                                      *-             Instantiating data constructors-*                                                                      *-************************************************************************--These InstPat functions go here to avoid circularity between DataCon and Id--}--dataConRepInstPat   ::                 [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])-dataConRepFSInstPat :: [FastString] -> [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])--dataConRepInstPat   = dataConInstPat (repeat ((fsLit "ipv")))-dataConRepFSInstPat = dataConInstPat--dataConInstPat :: [FastString]          -- A long enough list of FSs to use for names-               -> [Unique]              -- An equally long list of uniques, at least one for each binder-               -> DataCon-               -> [Type]                -- Types to instantiate the universally quantified tyvars-               -> ([TyCoVar], [Id])     -- Return instantiated variables--- dataConInstPat arg_fun fss us con inst_tys returns a tuple--- (ex_tvs, arg_ids),------   ex_tvs are intended to be used as binders for existential type args------   arg_ids are indended to be used as binders for value arguments,---     and their types have been instantiated with inst_tys and ex_tys---     The arg_ids include both evidence and---     programmer-specified arguments (both after rep-ing)------ Example.---  The following constructor T1------  data T a where---    T1 :: forall b. Int -> b -> T(a,b)---    ...------  has representation type---   forall a. forall a1. forall b. (a ~ (a1,b)) =>---     Int -> b -> T a------  dataConInstPat fss us T1 (a1',b') will return------  ([a1'', b''], [c :: (a1', b')~(a1'', b''), x :: Int, y :: b''])------  where the double-primed variables are created with the FastStrings and---  Uniques given as fss and us-dataConInstPat fss uniqs con inst_tys-  = ASSERT( univ_tvs `equalLength` inst_tys )-    (ex_bndrs, arg_ids)-  where-    univ_tvs = dataConUnivTyVars con-    ex_tvs   = dataConExTyCoVars con-    arg_tys  = dataConRepArgTys con-    arg_strs = dataConRepStrictness con  -- 1-1 with arg_tys-    n_ex = length ex_tvs--      -- split the Uniques and FastStrings-    (ex_uniqs, id_uniqs) = splitAt n_ex uniqs-    (ex_fss,   id_fss)   = splitAt n_ex fss--      -- Make the instantiating substitution for universals-    univ_subst = zipTvSubst univ_tvs inst_tys--      -- Make existential type variables, applying and extending the substitution-    (full_subst, ex_bndrs) = mapAccumL mk_ex_var univ_subst-                                       (zip3 ex_tvs ex_fss ex_uniqs)--    mk_ex_var :: TCvSubst -> (TyCoVar, FastString, Unique) -> (TCvSubst, TyCoVar)-    mk_ex_var subst (tv, fs, uniq) = (Type.extendTCvSubstWithClone subst tv-                                       new_tv-                                     , new_tv)-      where-        new_tv | isTyVar tv-               = mkTyVar (mkSysTvName uniq fs) kind-               | otherwise-               = mkCoVar (mkSystemVarName uniq fs) kind-        kind   = Type.substTyUnchecked subst (varType tv)--      -- Make value vars, instantiating types-    arg_ids = zipWith4 mk_id_var id_uniqs id_fss arg_tys arg_strs-    mk_id_var uniq fs ty str-      = setCaseBndrEvald str $  -- See Note [Mark evaluated arguments]-        mkLocalIdOrCoVar name (Type.substTy full_subst ty)-      where-        name = mkInternalName uniq (mkVarOccFS fs) noSrcSpan--{--Note [Mark evaluated arguments]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When pattern matching on a constructor with strict fields, the binder-can have an 'evaldUnfolding'.  Moreover, it *should* have one, so that-when loading an interface file unfolding like:-  data T = MkT !Int-  f x = case x of { MkT y -> let v::Int# = case y of I# n -> n+1-                             in ... }-we don't want Lint to complain.  The 'y' is evaluated, so the-case in the RHS of the binding for 'v' is fine.  But only if we-*know* that 'y' is evaluated.--c.f. add_evals in Simplify.simplAlt--************************************************************************-*                                                                      *-         Equality-*                                                                      *-************************************************************************--}---- | A cheap equality test which bales out fast!---      If it returns @True@ the arguments are definitely equal,---      otherwise, they may or may not be equal.------ See also 'exprIsBig'-cheapEqExpr :: Expr b -> Expr b -> Bool-cheapEqExpr = cheapEqExpr' (const False)---- | Cheap expression equality test, can ignore ticks by type.-cheapEqExpr' :: (Tickish Id -> Bool) -> Expr b -> Expr b -> Bool-cheapEqExpr' ignoreTick = go_s-  where go_s = go `on` stripTicksTopE ignoreTick-        go (Var v1)   (Var v2)   = v1 == v2-        go (Lit lit1) (Lit lit2) = lit1 == lit2-        go (Type t1)  (Type t2)  = t1 `eqType` t2-        go (Coercion c1) (Coercion c2) = c1 `eqCoercion` c2--        go (App f1 a1) (App f2 a2)-          = f1 `go_s` f2 && a1 `go_s` a2--        go (Cast e1 t1) (Cast e2 t2)-          = e1 `go_s` e2 && t1 `eqCoercion` t2--        go (Tick t1 e1) (Tick t2 e2)-          = t1 == t2 && e1 `go_s` e2--        go _ _ = False-        {-# INLINE go #-}-{-# INLINE cheapEqExpr' #-}--exprIsBig :: Expr b -> Bool--- ^ Returns @True@ of expressions that are too big to be compared by 'cheapEqExpr'-exprIsBig (Lit _)      = False-exprIsBig (Var _)      = False-exprIsBig (Type _)     = False-exprIsBig (Coercion _) = False-exprIsBig (Lam _ e)    = exprIsBig e-exprIsBig (App f a)    = exprIsBig f || exprIsBig a-exprIsBig (Cast e _)   = exprIsBig e    -- Hopefully coercions are not too big!-exprIsBig (Tick _ e)   = exprIsBig e-exprIsBig _            = True--eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool--- Compares for equality, modulo alpha-eqExpr in_scope e1 e2-  = go (mkRnEnv2 in_scope) e1 e2-  where-    go env (Var v1) (Var v2)-      | rnOccL env v1 == rnOccR env v2-      = True--    go _   (Lit lit1)    (Lit lit2)      = lit1 == lit2-    go env (Type t1)    (Type t2)        = eqTypeX env t1 t2-    go env (Coercion co1) (Coercion co2) = eqCoercionX env co1 co2-    go env (Cast e1 co1) (Cast e2 co2) = eqCoercionX env co1 co2 && go env e1 e2-    go env (App f1 a1)   (App f2 a2)   = go env f1 f2 && go env a1 a2-    go env (Tick n1 e1)  (Tick n2 e2)  = eqTickish env n1 n2 && go env e1 e2--    go env (Lam b1 e1)  (Lam b2 e2)-      =  eqTypeX env (varType b1) (varType b2)   -- False for Id/TyVar combination-      && go (rnBndr2 env b1 b2) e1 e2--    go env (Let (NonRec v1 r1) e1) (Let (NonRec v2 r2) e2)-      =  go env r1 r2  -- No need to check binder types, since RHSs match-      && go (rnBndr2 env v1 v2) e1 e2--    go env (Let (Rec ps1) e1) (Let (Rec ps2) e2)-      = equalLength ps1 ps2-      && all2 (go env') rs1 rs2 && go env' e1 e2-      where-        (bs1,rs1) = unzip ps1-        (bs2,rs2) = unzip ps2-        env' = rnBndrs2 env bs1 bs2--    go env (Case e1 b1 t1 a1) (Case e2 b2 t2 a2)-      | null a1   -- See Note [Empty case alternatives] in TrieMap-      = null a2 && go env e1 e2 && eqTypeX env t1 t2-      | otherwise-      =  go env e1 e2 && all2 (go_alt (rnBndr2 env b1 b2)) a1 a2--    go _ _ _ = False--    ------------    go_alt env (c1, bs1, e1) (c2, bs2, e2)-      = c1 == c2 && go (rnBndrs2 env bs1 bs2) e1 e2--eqTickish :: RnEnv2 -> Tickish Id -> Tickish Id -> Bool-eqTickish env (Breakpoint lid lids) (Breakpoint rid rids)-      = lid == rid  &&  map (rnOccL env) lids == map (rnOccR env) rids-eqTickish _ l r = l == r---- | Finds differences between core expressions, modulo alpha and--- renaming. Setting @top@ means that the @IdInfo@ of bindings will be--- checked for differences as well.-diffExpr :: Bool -> RnEnv2 -> CoreExpr -> CoreExpr -> [SDoc]-diffExpr _   env (Var v1)   (Var v2)   | rnOccL env v1 == rnOccR env v2 = []-diffExpr _   _   (Lit lit1) (Lit lit2) | lit1 == lit2                   = []-diffExpr _   env (Type t1)  (Type t2)  | eqTypeX env t1 t2              = []-diffExpr _   env (Coercion co1) (Coercion co2)-                                       | eqCoercionX env co1 co2        = []-diffExpr top env (Cast e1 co1)  (Cast e2 co2)-  | eqCoercionX env co1 co2                = diffExpr top env e1 e2-diffExpr top env (Tick n1 e1)   e2-  | not (tickishIsCode n1)                 = diffExpr top env e1 e2-diffExpr top env e1             (Tick n2 e2)-  | not (tickishIsCode n2)                 = diffExpr top env e1 e2-diffExpr top env (Tick n1 e1)   (Tick n2 e2)-  | eqTickish env n1 n2                    = diffExpr top env e1 e2- -- The error message of failed pattern matches will contain- -- generated names, which are allowed to differ.-diffExpr _   _   (App (App (Var absent) _) _)-                 (App (App (Var absent2) _) _)-  | isBottomingId absent && isBottomingId absent2 = []-diffExpr top env (App f1 a1)    (App f2 a2)-  = diffExpr top env f1 f2 ++ diffExpr top env a1 a2-diffExpr top env (Lam b1 e1)  (Lam b2 e2)-  | eqTypeX env (varType b1) (varType b2)   -- False for Id/TyVar combination-  = diffExpr top (rnBndr2 env b1 b2) e1 e2-diffExpr top env (Let bs1 e1) (Let bs2 e2)-  = 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)-  | 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-        diffAlt (c1, bs1, e1) (c2, bs2, e2)-          | c1 /= c2  = [text "alt-cons " <> ppr c1 <> text " /= " <> ppr c2]-          | otherwise = diffExpr top (rnBndrs2 env' bs1 bs2) e1 e2-diffExpr _  _ e1 e2-  = [fsep [ppr e1, text "/=", ppr e2]]---- | Finds differences between core bindings, see @diffExpr@.------ The main problem here is that while we expect the binds to have the--- same order in both lists, this is not guaranteed. To do this--- properly we'd either have to do some sort of unification or check--- all possible mappings, which would be seriously expensive. So--- instead we simply match single bindings as far as we can. This--- leaves us just with mutually recursive and/or mismatching bindings,--- which we then speculatively match by ordering them. It's by no means--- perfect, but gets the job done well enough.-diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)]-          -> ([SDoc], RnEnv2)-diffBinds top env binds1 = go (length binds1) env binds1- where go _    env []     []-          = ([], env)-       go fuel env binds1 binds2-          -- No binds left to compare? Bail out early.-          | null binds1 || null binds2-          = (warn env binds1 binds2, env)-          -- Iterated over all binds without finding a match? Then-          -- try speculatively matching binders by order.-          | fuel == 0-          = if not $ env `inRnEnvL` fst (head binds1)-            then let env' = uncurry (rnBndrs2 env) $ unzip $-                            zip (sort $ map fst binds1) (sort $ map fst binds2)-                 in go (length binds1) env' binds1 binds2-            -- If we have already tried that, give up-            else (warn env binds1 binds2, env)-       go fuel env ((bndr1,expr1):binds1) binds2-          | let matchExpr (bndr,expr) =-                  (not top || null (diffIdInfo env bndr bndr1)) &&-                  null (diffExpr top (rnBndr2 env bndr1 bndr) expr1 expr)-          , (binds2l, (bndr2,_):binds2r) <- break matchExpr binds2-          = go (length binds1) (rnBndr2 env bndr1 bndr2)-                binds1 (binds2l ++ binds2r)-          | otherwise -- No match, so push back (FIXME O(n^2))-          = go (fuel-1) env (binds1++[(bndr1,expr1)]) binds2-       go _ _ _ _ = panic "diffBinds: impossible" -- GHC isn't smart enough--       -- We have tried everything, but couldn't find a good match. So-       -- now we just return the comparison results when we pair up-       -- the binds in a pseudo-random order.-       warn env binds1 binds2 =-         concatMap (uncurry (diffBind env)) (zip binds1' binds2') ++-         unmatched "unmatched left-hand:" (drop l binds1') ++-         unmatched "unmatched right-hand:" (drop l binds2')-        where binds1' = sortBy (comparing fst) binds1-              binds2' = sortBy (comparing fst) binds2-              l = min (length binds1') (length binds2')-       unmatched _   [] = []-       unmatched txt bs = [text txt $$ ppr (Rec bs)]-       diffBind env (bndr1,expr1) (bndr2,expr2)-         | ds@(_:_) <- diffExpr top env expr1 expr2-         = locBind "in binding" bndr1 bndr2 ds-         | otherwise-         = diffIdInfo env bndr1 bndr2---- | Find differences in @IdInfo@. We will especially check whether--- the unfoldings match, if present (see @diffUnfold@).-diffIdInfo :: RnEnv2 -> Var -> Var -> [SDoc]-diffIdInfo env bndr1 bndr2-  | arityInfo info1 == arityInfo info2-    && cafInfo info1 == cafInfo info2-    && oneShotInfo info1 == oneShotInfo info2-    && inlinePragInfo info1 == inlinePragInfo info2-    && occInfo info1 == occInfo info2-    && demandInfo info1 == demandInfo info2-    && callArityInfo info1 == callArityInfo info2-    && levityInfo info1 == levityInfo info2-  = locBind "in unfolding of" bndr1 bndr2 $-    diffUnfold env (unfoldingInfo info1) (unfoldingInfo info2)-  | otherwise-  = locBind "in Id info of" bndr1 bndr2-    [fsep [pprBndr LetBind bndr1, text "/=", pprBndr LetBind bndr2]]-  where info1 = idInfo bndr1; info2 = idInfo bndr2---- | Find differences in unfoldings. Note that we will not check for--- differences of @IdInfo@ in unfoldings, as this is generally--- redundant, and can lead to an exponential blow-up in complexity.-diffUnfold :: RnEnv2 -> Unfolding -> Unfolding -> [SDoc]-diffUnfold _   NoUnfolding    NoUnfolding                 = []-diffUnfold _   BootUnfolding  BootUnfolding               = []-diffUnfold _   (OtherCon cs1) (OtherCon cs2) | cs1 == cs2 = []-diffUnfold env (DFunUnfolding bs1 c1 a1)-               (DFunUnfolding bs2 c2 a2)-  | 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)-               (CoreUnfolding t2 _ _ v2 cl2 wf2 x2 g2)-  | v1 == v2 && cl1 == cl2-    && wf1 == wf2 && x1 == x2 && g1 == g2-  = diffExpr False env t1 t2-diffUnfold _   uf1 uf2-  = [fsep [ppr uf1, text "/=", ppr uf2]]---- | Add location information to diff messages-locBind :: String -> Var -> Var -> [SDoc] -> [SDoc]-locBind loc b1 b2 diffs = map addLoc diffs-  where addLoc d            = d $$ nest 2 (parens (text loc <+> bindLoc))-        bindLoc | b1 == b2  = ppr b1-                | otherwise = ppr b1 <> char '/' <> ppr b2--{--************************************************************************-*                                                                      *-                Eta reduction-*                                                                      *-************************************************************************--Note [Eta reduction conditions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We try for eta reduction here, but *only* if we get all the way to an-trivial expression.  We don't want to remove extra lambdas unless we-are going to avoid allocating this thing altogether.--There are some particularly delicate points here:--* We want to eta-reduce if doing so leaves a trivial expression,-  *including* a cast.  For example-       \x. f |> co  -->  f |> co-  (provided co doesn't mention x)--* Eta reduction is not valid in general:-        \x. bot  /=  bot-  This matters, partly for old-fashioned correctness reasons but,-  worse, getting it wrong can yield a seg fault. Consider-        f = \x.f x-        h y = case (case y of { True -> f `seq` True; False -> False }) of-                True -> ...; False -> ...--  If we (unsoundly) eta-reduce f to get f=f, the strictness analyser-  says f=bottom, and replaces the (f `seq` True) with just-  (f `cast` unsafe-co).  BUT, as thing stand, 'f' got arity 1, and it-  *keeps* arity 1 (perhaps also wrongly).  So CorePrep eta-expands-  the definition again, so that it does not termninate after all.-  Result: seg-fault because the boolean case actually gets a function value.-  See #1947.--  So it's important to do the right thing.--* Note [Arity care]: we need to be careful if we just look at f's-  arity. Currently (Dec07), f's arity is visible in its own RHS (see-  Note [Arity robustness] in SimplEnv) so we must *not* trust the-  arity when checking that 'f' is a value.  Otherwise we will-  eta-reduce-      f = \x. f x-  to-      f = f-  Which might change a terminating program (think (f `seq` e)) to a-  non-terminating one.  So we check for being a loop breaker first.--  However for GlobalIds we can look at the arity; and for primops we-  must, since they have no unfolding.--* Regardless of whether 'f' is a value, we always want to-  reduce (/\a -> f a) to f-  This came up in a RULE: foldr (build (/\a -> g a))-  did not match           foldr (build (/\b -> ...something complex...))-  The type checker can insert these eta-expanded versions,-  with both type and dictionary lambdas; hence the slightly-  ad-hoc isDictId--* Never *reduce* arity. For example-      f = \xy. g x y-  Then if h has arity 1 we don't want to eta-reduce because then-  f's arity would decrease, and that is bad--These delicacies are why we don't use exprIsTrivial and exprIsHNF here.-Alas.--Note [Eta reduction with casted arguments]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-    (\(x:t3). f (x |> g)) :: t3 -> t2-  where-    f :: t1 -> t2-    g :: t3 ~ t1-This should be eta-reduced to--    f |> (sym g -> t2)--So we need to accumulate a coercion, pushing it inward (past-variable arguments only) thus:-   f (x |> co_arg) |> co  -->  (f |> (sym co_arg -> co)) x-   f (x:t)         |> co  -->  (f |> (t -> co)) x-   f @ a           |> co  -->  (f |> (forall a.co)) @ a-   f @ (g:t1~t2)   |> co  -->  (f |> (t1~t2 => co)) @ (g:t1~t2)-These are the equations for ok_arg.--It's true that we could also hope to eta reduce these:-    (\xy. (f x |> g) y)-    (\xy. (f x y) |> g)-But the simplifier pushes those casts outwards, so we don't-need to address that here.--}---- When updating this function, make sure to update--- CorePrep.tryEtaReducePrep as well!-tryEtaReduce :: [Var] -> CoreExpr -> Maybe CoreExpr-tryEtaReduce bndrs body-  = go (reverse bndrs) body (mkRepReflCo (exprType body))-  where-    incoming_arity = count isId bndrs--    go :: [Var]            -- Binders, innermost first, types [a3,a2,a1]-       -> CoreExpr         -- Of type tr-       -> Coercion         -- Of type tr ~ ts-       -> Maybe CoreExpr   -- Of type a1 -> a2 -> a3 -> ts-    -- See Note [Eta reduction with casted arguments]-    -- for why we have an accumulating coercion-    go [] fun co-      | ok_fun fun-      , let used_vars = exprFreeVars fun `unionVarSet` tyCoVarsOfCo co-      , not (any (`elemVarSet` used_vars) bndrs)-      = Just (mkCast fun co)   -- Check for any of the binders free in the result-                               -- including the accumulated coercion--    go bs (Tick t e) co-      | tickishFloatable t-      = fmap (Tick t) $ go bs e co-      -- Float app ticks: \x -> Tick t (e x) ==> Tick t e--    go (b : bs) (App fun arg) co-      | Just (co', ticks) <- ok_arg b arg co-      = fmap (flip (foldr mkTick) ticks) $ go bs fun co'-            -- Float arg ticks: \x -> e (Tick t x) ==> Tick t e--    go _ _ _  = Nothing         -- Failure!--    ----------------    -- Note [Eta reduction conditions]-    ok_fun (App fun (Type {})) = ok_fun fun-    ok_fun (Cast fun _)        = ok_fun fun-    ok_fun (Tick _ expr)       = ok_fun expr-    ok_fun (Var fun_id)        = ok_fun_id fun_id || all ok_lam bndrs-    ok_fun _fun                = False--    ----------------    ok_fun_id fun = fun_arity fun >= incoming_arity--    ----------------    fun_arity fun             -- See Note [Arity care]-       | isLocalId fun-       , isStrongLoopBreaker (idOccInfo fun) = 0-       | arity > 0                           = arity-       | isEvaldUnfolding (idUnfolding fun)  = 1-            -- See Note [Eta reduction of an eval'd function]-       | otherwise                           = 0-       where-         arity = idArity fun--    ----------------    ok_lam v = isTyVar v || isEvVar v--    ----------------    ok_arg :: Var              -- Of type bndr_t-           -> CoreExpr         -- Of type arg_t-           -> Coercion         -- Of kind (t1~t2)-           -> Maybe (Coercion  -- Of type (arg_t -> t1 ~  bndr_t -> t2)-                               --   (and similarly for tyvars, coercion args)-                    , [Tickish Var])-    -- See Note [Eta reduction with casted arguments]-    ok_arg bndr (Type ty) co-       | Just tv <- getTyVar_maybe ty-       , bndr == tv  = Just (mkHomoForAllCos [tv] co, [])-    ok_arg bndr (Var v) co-       | bndr == v   = let reflCo = mkRepReflCo (idType bndr)-                       in Just (mkFunCo Representational reflCo co, [])-    ok_arg bndr (Cast e co_arg) co-       | (ticks, Var v) <- stripTicksTop tickishFloatable e-       , bndr == v-       = Just (mkFunCo Representational (mkSymCo co_arg) co, ticks)-       -- The simplifier combines multiple casts into one,-       -- so we can have a simple-minded pattern match here-    ok_arg bndr (Tick t arg) co-       | tickishFloatable t, Just (co', ticks) <- ok_arg bndr arg co-       = Just (co', t:ticks)--    ok_arg _ _ _ = Nothing--{--Note [Eta reduction of an eval'd function]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In Haskell it is not true that    f = \x. f x-because f might be bottom, and 'seq' can distinguish them.--But it *is* true that   f = f `seq` \x. f x-and we'd like to simplify the latter to the former.  This amounts-to the rule that-  * when there is just *one* value argument,-  * f is not bottom-we can eta-reduce    \x. f x  ===>  f--This turned up in #7542.---************************************************************************-*                                                                      *-\subsection{Determining non-updatable right-hand-sides}-*                                                                      *-************************************************************************--Top-level constructor applications can usually be allocated-statically, but they can't if the constructor, or any of the-arguments, come from another DLL (because we can't refer to static-labels in other DLLs).--If this happens we simply make the RHS into an updatable thunk,-and 'execute' it rather than allocating it statically.--}---- | This function is called only on *top-level* right-hand sides.--- Returns @True@ if the RHS can be allocated statically in the output,--- with no thunks involved at all.-rhsIsStatic-   :: Platform-   -> (Name -> Bool)         -- Which names are dynamic-   -> (LitNumType -> Integer -> Maybe CoreExpr)-      -- Desugaring for some literals (disgusting)-      -- C.f. Note [Disgusting computation of CafRefs] in GHC.Iface.Tidy-   -> CoreExpr -> Bool--- It's called (i) in GHC.Iface.Tidy.hasCafRefs to decide if the rhs is, or--- refers to, CAFs; (ii) in CoreToStg to decide whether to put an--- update flag on it and (iii) in DsExpr to decide how to expand--- list literals------ The basic idea is that rhsIsStatic returns True only if the RHS is---      (a) a value lambda---      (b) a saturated constructor application with static args------ BUT watch out for---  (i) Any cross-DLL references kill static-ness completely---      because they must be 'executed' not statically allocated---      ("DLL" here really only refers to Windows DLLs, on other platforms,---      this is not necessary)------ (ii) We treat partial applications as redexes, because in fact we---      make a thunk for them that runs and builds a PAP---      at run-time.  The only applications that are treated as---      static are *saturated* applications of constructors.---- We used to try to be clever with nested structures like this:---              ys = (:) w ((:) w [])--- on the grounds that CorePrep will flatten ANF-ise it later.--- But supporting this special case made the function much more--- complicated, because the special case only applies if there are no--- enclosing type lambdas:---              ys = /\ a -> Foo (Baz ([] a))--- Here the nested (Baz []) won't float out to top level in CorePrep.------ But in fact, even without -O, nested structures at top level are--- flattened by the simplifier, so we don't need to be super-clever here.------ Examples------      f = \x::Int. x+7        TRUE---      p = (True,False)        TRUE------      d = (fst p, False)      FALSE because there's a redex inside---                              (this particular one doesn't happen but...)------      h = D# (1.0## /## 2.0##)        FALSE (redex again)---      n = /\a. Nil a                  TRUE------      t = /\a. (:) (case w a of ...) (Nil a)  FALSE (redex)--------- This is a bit like CoreUtils.exprIsHNF, with the following differences:---    a) scc "foo" (\x -> ...) is updatable (so we catch the right SCC)------    b) (C x xs), where C is a constructor is updatable if the application is---         dynamic------    c) don't look through unfolding of f in (f x).--rhsIsStatic platform is_dynamic_name cvt_literal rhs = is_static False rhs-  where-  is_static :: Bool     -- True <=> in a constructor argument; must be atomic-            -> CoreExpr -> Bool--  is_static False  (Lam b e)              = isRuntimeVar b || is_static False e-  is_static in_arg (Tick n e)             = not (tickishIsCode n)-                                              && is_static in_arg e-  is_static in_arg (Cast e _)             = is_static in_arg e-  is_static _      (Coercion {})          = True   -- Behaves just like a literal-  is_static in_arg (Lit (LitNumber nt i _)) = case cvt_literal nt i of-    Just e  -> is_static in_arg e-    Nothing -> True-  is_static _      (Lit (LitLabel {}))    = False-  is_static _      (Lit _)                = True-        -- A LitLabel (foreign import "&foo") in an argument-        -- prevents a constructor application from being static.  The-        -- reason is that it might give rise to unresolvable symbols-        -- in the object file: under Linux, references to "weak"-        -- symbols from the data segment give rise to "unresolvable-        -- relocation" errors at link time This might be due to a bug-        -- in the linker, but we'll work around it here anyway.-        -- SDM 24/2/2004--  is_static in_arg other_expr = go other_expr 0-   where-    go (Var f) n_val_args-        | (platformOS platform /= OSMinGW32) ||-          not (is_dynamic_name (idName f))-        =  saturated_data_con f n_val_args-        || (in_arg && n_val_args == 0)-                -- A naked un-applied variable is *not* deemed a static RHS-                -- E.g.         f = g-                -- Reason: better to update so that the indirection gets shorted-                --         out, and the true value will be seen-                -- NB: if you change this, you'll break the invariant that THUNK_STATICs-                --     are always updatable.  If you do so, make sure that non-updatable-                --     ones have enough space for their static link field!--    go (App f a) n_val_args-        | isTypeArg a                    = go f n_val_args-        | not in_arg && is_static True a = go f (n_val_args + 1)-        -- The (not in_arg) checks that we aren't in a constructor argument;-        -- if we are, we don't allow (value) applications of any sort-        ---        -- NB. In case you wonder, args are sometimes not atomic.  eg.-        --   x = D# (1.0## /## 2.0##)-        -- can't float because /## can fail.--    go (Tick n f) n_val_args = not (tickishIsCode n) && go f n_val_args-    go (Cast e _) n_val_args = go e n_val_args-    go _          _          = False--    saturated_data_con f n_val_args-        = case isDataConWorkId_maybe f of-            Just dc -> n_val_args == dataConRepArity dc-            Nothing -> False--{--************************************************************************-*                                                                      *-\subsection{Type utilities}-*                                                                      *-************************************************************************--}---- | True if the type has no non-bottom elements, e.g. when it is an empty--- datatype, or a GADT with non-satisfiable type parameters, e.g. Int :~: Bool.--- See Note [Bottoming expressions]------ See Note [No alternatives lint check] for another use of this function.-isEmptyTy :: Type -> Bool-isEmptyTy ty-    -- Data types where, given the particular type parameters, no data-    -- constructor matches, are empty.-    -- This includes data types with no constructors, e.g. Data.Void.Void.-    | Just (tc, inst_tys) <- splitTyConApp_maybe ty-    , Just dcs <- tyConDataCons_maybe tc-    , all (dataConCannotMatch inst_tys) dcs-    = True-    | otherwise-    = False--{--*****************************************************-*-* StaticPtr-*-*****************************************************--}---- | @collectMakeStaticArgs (makeStatic t srcLoc e)@ yields--- @Just (makeStatic, t, srcLoc, e)@.------ Returns @Nothing@ for every other expression.-collectMakeStaticArgs-  :: CoreExpr -> Maybe (CoreExpr, Type, CoreExpr, CoreExpr)-collectMakeStaticArgs e-    | (fun@(Var b), [Type t, loc, arg], _) <- collectArgsTicks (const True) e-    , idName b == makeStaticName = Just (fun, t, loc, arg)-collectMakeStaticArgs _          = Nothing--{--************************************************************************-*                                                                      *-\subsection{Join points}-*                                                                      *-************************************************************************--}---- | Does this binding bind a join point (or a recursive group of join points)?-isJoinBind :: CoreBind -> Bool-isJoinBind (NonRec b _)       = isJoinId b-isJoinBind (Rec ((b, _) : _)) = isJoinId b-isJoinBind _                  = False

− compiler/coreSyn/MkCore.hs

@@ -1,937 +0,0 @@-{-# LANGUAGE CPP #-}--{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}---- | Handy functions for creating much Core syntax-module MkCore (-        -- * Constructing normal syntax-        mkCoreLet, mkCoreLets,-        mkCoreApp, mkCoreApps, mkCoreConApps,-        mkCoreLams, mkWildCase, mkIfThenElse,-        mkWildValBinder, mkWildEvBinder,-        mkSingleAltCase,-        sortQuantVars, castBottomExpr,--        -- * Constructing boxed literals-        mkWordExpr, mkWordExprWord,-        mkIntExpr, mkIntExprInt,-        mkIntegerExpr, mkNaturalExpr,-        mkFloatExpr, mkDoubleExpr,-        mkCharExpr, mkStringExpr, mkStringExprFS, mkStringExprFSWith,--        -- * Floats-        FloatBind(..), wrapFloat, wrapFloats, floatBindings,--        -- * Constructing small tuples-        mkCoreVarTupTy, mkCoreTup, mkCoreUbxTup,-        mkCoreTupBoxity, unitExpr,--        -- * Constructing big tuples-        mkBigCoreVarTup, mkBigCoreVarTup1,-        mkBigCoreVarTupTy, mkBigCoreTupTy,-        mkBigCoreTup,--        -- * Deconstructing small tuples-        mkSmallTupleSelector, mkSmallTupleCase,--        -- * Deconstructing big tuples-        mkTupleSelector, mkTupleSelector1, mkTupleCase,--        -- * Constructing list expressions-        mkNilExpr, mkConsExpr, mkListExpr,-        mkFoldrExpr, mkBuildExpr,--        -- * Constructing Maybe expressions-        mkNothingExpr, mkJustExpr,--        -- * Error Ids-        mkRuntimeErrorApp, mkImpossibleExpr, mkAbsentErrorApp, errorIds,-        rEC_CON_ERROR_ID, rUNTIME_ERROR_ID,-        nON_EXHAUSTIVE_GUARDS_ERROR_ID, nO_METHOD_BINDING_ERROR_ID,-        pAT_ERROR_ID, rEC_SEL_ERROR_ID, aBSENT_ERROR_ID,-        tYPE_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID-    ) where--#include "HsVersions.h"--import GhcPrelude--import Id-import Var      ( EvVar, setTyVarUnique )--import CoreSyn-import CoreUtils        ( exprType, needsCaseBinding, mkSingleAltCase, bindNonRec )-import Literal-import HscTypes--import TysWiredIn-import PrelNames--import GHC.Hs.Utils     ( mkChunkified, chunkify )-import Type-import Coercion         ( isCoVar )-import TysPrim-import DataCon          ( DataCon, dataConWorkId )-import IdInfo-import Demand-import Name      hiding ( varName )-import Outputable-import FastString-import UniqSupply-import BasicTypes-import Util-import DynFlags-import Data.List--import Data.Char        ( ord )-import Control.Monad.Fail as MonadFail ( MonadFail )--infixl 4 `mkCoreApp`, `mkCoreApps`--{--************************************************************************-*                                                                      *-\subsection{Basic CoreSyn construction}-*                                                                      *-************************************************************************--}-sortQuantVars :: [Var] -> [Var]--- Sort the variables, putting type and covars first, in scoped order,--- and then other Ids--- It is a deterministic sort, meaining it doesn't look at the values of--- Uniques. For explanation why it's important See Note [Unique Determinism]--- in Unique.-sortQuantVars vs = sorted_tcvs ++ ids-  where-    (tcvs, ids) = partition (isTyVar <||> isCoVar) vs-    sorted_tcvs = scopedSort tcvs---- | Bind a binding group over an expression, using a @let@ or @case@ as--- appropriate (see "CoreSyn#let_app_invariant")-mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr-mkCoreLet (NonRec bndr rhs) body        -- See Note [CoreSyn let/app invariant]-  = bindNonRec bndr rhs body-mkCoreLet bind body-  = Let bind body---- | Create a lambda where the given expression has a number of variables--- bound over it. The leftmost binder is that bound by the outermost--- lambda in the result-mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr-mkCoreLams = mkLams---- | Bind a list of binding groups over an expression. The leftmost binding--- group becomes the outermost group in the resulting expression-mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr-mkCoreLets binds body = foldr mkCoreLet body binds---- | Construct an expression which represents the application of a number of--- expressions to that of a data constructor expression. The leftmost expression--- in the list is applied first-mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr-mkCoreConApps con args = mkCoreApps (Var (dataConWorkId con)) args---- | 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-mkCoreApps fun args-  = fst $-    foldl' (mkCoreAppTyped doc_string) (fun, fun_ty) args-  where-    doc_string = ppr fun_ty $$ ppr fun $$ ppr args-    fun_ty = exprType fun---- | Construct an expression which represents the application of one expression--- to the other--- Respects the let/app invariant by building a case expression where necessary---   See CoreSyn Note [CoreSyn let/app invariant]-mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr-mkCoreApp s fun arg-  = fst $ mkCoreAppTyped s (fun, exprType fun) arg---- | 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), funResultTy fun_ty)-mkCoreAppTyped d (fun, fun_ty) arg-  = ASSERT2( isFunTy fun_ty, ppr fun $$ ppr arg $$ d )-    (mkValApp fun arg arg_ty res_ty, res_ty)-  where-    (arg_ty, res_ty) = splitFunTy fun_ty--mkValApp :: CoreExpr -> CoreExpr -> Type -> Type -> CoreExpr--- Build an application (e1 e2),--- or a strict binding  (case e2 of x -> e1 x)--- using the latter when necessary to respect the let/app invariant---   See Note [CoreSyn let/app invariant]-mkValApp fun arg arg_ty res_ty-  | not (needsCaseBinding arg_ty arg)-  = App fun arg                -- The vastly common case-  | otherwise-  = mkStrictApp fun arg arg_ty res_ty--{- *********************************************************************-*                                                                      *-              Building case expressions-*                                                                      *-********************************************************************* -}--mkWildEvBinder :: PredType -> EvVar-mkWildEvBinder pred = mkWildValBinder pred---- | Make a /wildcard binder/. This is typically used when you need a binder--- that you expect to use only at a *binding* site.  Do not use it at--- occurrence sites because it has a single, fixed unique, and it's very--- easy to get into difficulties with shadowing.  That's why it is used so little.--- See Note [WildCard binders] in SimplEnv-mkWildValBinder :: Type -> Id-mkWildValBinder ty = mkLocalIdOrCoVar wildCardName ty-  -- "OrCoVar" since a coercion can be a scrutinee with -fdefer-type-errors-  -- (e.g. see test T15695). Ticket #17291 covers fixing this problem.--mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr--- Make a case expression whose case binder is unused--- The alts and res_ty should not have any occurrences of WildId-mkWildCase scrut scrut_ty res_ty alts-  = Case scrut (mkWildValBinder scrut_ty) res_ty alts--mkStrictApp :: CoreExpr -> CoreExpr -> Type -> Type -> CoreExpr--- Build a strict application (case e2 of x -> e1 x)-mkStrictApp fun arg arg_ty res_ty-  = Case arg arg_id res_ty [(DEFAULT,[],App fun (Var arg_id))]-       -- mkDefaultCase looks attractive here, and would be sound.-       -- But it uses (exprType alt_rhs) to compute the result type,-       -- whereas here we already know that the result type is res_ty-  where-    arg_id = mkWildValBinder arg_ty-        -- Lots of shadowing, but it doesn't matter,-        -- because 'fun' and 'res_ty' should not have a free wild-id-        ---        -- This is Dangerous.  But this is the only place we play this-        -- game, mkStrictApp returns an expression that does not have-        -- a free wild-id.  So the only way 'fun' could get a free wild-id-        -- would be if you take apart this case expression (or some other-        -- expression that uses mkWildValBinder, of which there are not-        -- many), and pass a fragment of it as the fun part of a 'mkStrictApp'.--mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr-mkIfThenElse guard then_expr else_expr--- Not going to be refining, so okay to take the type of the "then" clause-  = mkWildCase guard boolTy (exprType then_expr)-         [ (DataAlt falseDataCon, [], else_expr),       -- Increasing order of tag!-           (DataAlt trueDataCon,  [], then_expr) ]--castBottomExpr :: CoreExpr -> Type -> CoreExpr--- (castBottomExpr e ty), assuming that 'e' diverges,--- return an expression of type 'ty'--- See Note [Empty case alternatives] in CoreSyn-castBottomExpr e res_ty-  | e_ty `eqType` res_ty = e-  | otherwise            = Case e (mkWildValBinder e_ty) res_ty []-  where-    e_ty = exprType e--{--************************************************************************-*                                                                      *-\subsection{Making literals}-*                                                                      *-************************************************************************--}---- | Create a 'CoreExpr' which will evaluate to the given @Int@-mkIntExpr :: DynFlags -> Integer -> CoreExpr        -- Result = I# i :: Int-mkIntExpr dflags i = mkCoreConApps intDataCon  [mkIntLit dflags i]---- | Create a 'CoreExpr' which will evaluate to the given @Int@-mkIntExprInt :: DynFlags -> Int -> CoreExpr         -- Result = I# i :: Int-mkIntExprInt dflags i = mkCoreConApps intDataCon  [mkIntLitInt dflags i]---- | Create a 'CoreExpr' which will evaluate to the a @Word@ with the given value-mkWordExpr :: DynFlags -> Integer -> CoreExpr-mkWordExpr dflags w = mkCoreConApps wordDataCon [mkWordLit dflags w]---- | Create a 'CoreExpr' which will evaluate to the given @Word@-mkWordExprWord :: DynFlags -> Word -> CoreExpr-mkWordExprWord dflags w = mkCoreConApps wordDataCon [mkWordLitWord dflags w]---- | Create a 'CoreExpr' which will evaluate to the given @Integer@-mkIntegerExpr  :: MonadThings m => Integer -> m CoreExpr  -- Result :: Integer-mkIntegerExpr i = do t <- lookupTyCon integerTyConName-                     return (Lit (mkLitInteger i (mkTyConTy t)))---- | Create a 'CoreExpr' which will evaluate to the given @Natural@-mkNaturalExpr  :: MonadThings m => Integer -> m CoreExpr-mkNaturalExpr i = do t <- lookupTyCon naturalTyConName-                     return (Lit (mkLitNatural i (mkTyConTy t)))---- | Create a 'CoreExpr' which will evaluate to the given @Float@-mkFloatExpr :: Float -> CoreExpr-mkFloatExpr f = mkCoreConApps floatDataCon [mkFloatLitFloat f]---- | Create a 'CoreExpr' which will evaluate to the given @Double@-mkDoubleExpr :: Double -> CoreExpr-mkDoubleExpr d = mkCoreConApps doubleDataCon [mkDoubleLitDouble d]----- | Create a 'CoreExpr' which will evaluate to the given @Char@-mkCharExpr     :: Char             -> CoreExpr      -- Result = C# c :: Int-mkCharExpr c = mkCoreConApps charDataCon [mkCharLit c]---- | Create a 'CoreExpr' which will evaluate to the given @String@-mkStringExpr   :: MonadThings m => String     -> m CoreExpr  -- Result :: String---- | Create a 'CoreExpr' which will evaluate to a string morally equivalent to the given @FastString@-mkStringExprFS :: MonadThings m => FastString -> m CoreExpr  -- Result :: String--mkStringExpr str = mkStringExprFS (mkFastString str)--mkStringExprFS = mkStringExprFSWith lookupId--mkStringExprFSWith :: Monad m => (Name -> m Id) -> FastString -> m CoreExpr-mkStringExprFSWith lookupM str-  | nullFS str-  = return (mkNilExpr charTy)--  | all safeChar chars-  = do unpack_id <- lookupM unpackCStringName-       return (App (Var unpack_id) lit)--  | otherwise-  = do unpack_utf8_id <- lookupM unpackCStringUtf8Name-       return (App (Var unpack_utf8_id) lit)--  where-    chars = unpackFS str-    safeChar c = ord c >= 1 && ord c <= 0x7F-    lit = Lit (LitString (bytesFS str))--{--************************************************************************-*                                                                      *-\subsection{Tuple constructors}-*                                                                      *-************************************************************************--}--{--Creating tuples and their types for Core expressions--@mkBigCoreVarTup@ builds a tuple; the inverse to @mkTupleSelector@.--* If it has only one element, it is the identity function.--* If there are more elements than a big tuple can have, it nests-  the tuples.--Note [Flattening one-tuples]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-This family of functions creates a tuple of variables/expressions/types.-  mkCoreTup [e1,e2,e3] = (e1,e2,e3)-What if there is just one variable/expression/type in the argument?-We could do one of two things:--* Flatten it out, so that-    mkCoreTup [e1] = e1--* Build a one-tuple (see Note [One-tuples] in TysWiredIn)-    mkCoreTup1 [e1] = Unit e1-  We use a suffix "1" to indicate this.--Usually we want the former, but occasionally the latter.--NB: The logic in tupleDataCon knows about () and Unit and (,), etc.--Note [Don't flatten tuples from HsSyn]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we get an explicit 1-tuple from HsSyn somehow (likely: Template Haskell),-we should treat it really as a 1-tuple, without flattening. Note that a-1-tuple and a flattened value have different performance and laziness-characteristics, so should just do what we're asked.--This arose from discussions in #16881.--One-tuples that arise internally depend on the circumstance; often flattening-is a good idea. Decisions are made on a case-by-case basis.---}---- | Build the type of a small tuple that holds the specified variables--- One-tuples are flattened; see Note [Flattening one-tuples]-mkCoreVarTupTy :: [Id] -> Type-mkCoreVarTupTy ids = mkBoxedTupleTy (map idType ids)---- | Build a small tuple holding the specified expressions--- One-tuples are flattened; see Note [Flattening one-tuples]-mkCoreTup :: [CoreExpr] -> CoreExpr-mkCoreTup [c] = c-mkCoreTup cs  = mkCoreTup1 cs   -- non-1-tuples are uniform---- | Build a small tuple holding the specified expressions--- One-tuples are *not* flattened; see Note [Flattening one-tuples]--- See also Note [Don't flatten tuples from HsSyn]-mkCoreTup1 :: [CoreExpr] -> CoreExpr-mkCoreTup1 cs = mkCoreConApps (tupleDataCon Boxed (length cs))-                              (map (Type . exprType) cs ++ cs)---- | Build a small unboxed tuple holding the specified expressions,--- with the given types. The types must be the types of the expressions.--- Do not include the RuntimeRep specifiers; this function calculates them--- for you.--- Does /not/ flatten one-tuples; see Note [Flattening one-tuples]-mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr-mkCoreUbxTup tys exps-  = ASSERT( tys `equalLength` exps)-    mkCoreConApps (tupleDataCon Unboxed (length tys))-             (map (Type . getRuntimeRep) tys ++ map Type tys ++ exps)---- | Make a core tuple of the given boxity; don't flatten 1-tuples-mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr-mkCoreTupBoxity Boxed   exps = mkCoreTup1 exps-mkCoreTupBoxity Unboxed exps = mkCoreUbxTup (map exprType exps) exps---- | Build a big tuple holding the specified variables--- One-tuples are flattened; see Note [Flattening one-tuples]-mkBigCoreVarTup :: [Id] -> CoreExpr-mkBigCoreVarTup ids = mkBigCoreTup (map Var ids)--mkBigCoreVarTup1 :: [Id] -> CoreExpr--- Same as mkBigCoreVarTup, but one-tuples are NOT flattened---                          see Note [Flattening one-tuples]-mkBigCoreVarTup1 [id] = mkCoreConApps (tupleDataCon Boxed 1)-                                      [Type (idType id), Var id]-mkBigCoreVarTup1 ids  = mkBigCoreTup (map Var ids)---- | Build the type of a big tuple that holds the specified variables--- One-tuples are flattened; see Note [Flattening one-tuples]-mkBigCoreVarTupTy :: [Id] -> Type-mkBigCoreVarTupTy ids = mkBigCoreTupTy (map idType ids)---- | Build a big tuple holding the specified expressions--- One-tuples are flattened; see Note [Flattening one-tuples]-mkBigCoreTup :: [CoreExpr] -> CoreExpr-mkBigCoreTup = mkChunkified mkCoreTup---- | Build the type of a big tuple that holds the specified type of thing--- One-tuples are flattened; see Note [Flattening one-tuples]-mkBigCoreTupTy :: [Type] -> Type-mkBigCoreTupTy = mkChunkified mkBoxedTupleTy---- | The unit expression-unitExpr :: CoreExpr-unitExpr = Var unitDataConId--{--************************************************************************-*                                                                      *-\subsection{Tuple destructors}-*                                                                      *-************************************************************************--}---- | Builds a selector which scrutises the given--- expression and extracts the one name from the list given.--- If you want the no-shadowing rule to apply, the caller--- is responsible for making sure that none of these names--- are in scope.------ If there is just one 'Id' in the tuple, then the selector is--- just the identity.------ If necessary, we pattern match on a \"big\" tuple.-mkTupleSelector, mkTupleSelector1-    :: [Id]         -- ^ The 'Id's to pattern match the tuple against-    -> Id           -- ^ The 'Id' to select-    -> Id           -- ^ A variable of the same type as the scrutinee-    -> CoreExpr     -- ^ Scrutinee-    -> CoreExpr     -- ^ Selector expression---- mkTupleSelector [a,b,c,d] b v e---          = case e of v {---                (p,q) -> case p of p {---                           (a,b) -> b }}--- We use 'tpl' vars for the p,q, since shadowing does not matter.------ In fact, it's more convenient to generate it innermost first, getting------        case (case e of v---                (p,q) -> p) of p---          (a,b) -> b-mkTupleSelector vars the_var scrut_var scrut-  = mk_tup_sel (chunkify vars) the_var-  where-    mk_tup_sel [vars] the_var = mkSmallTupleSelector vars the_var scrut_var scrut-    mk_tup_sel vars_s the_var = mkSmallTupleSelector group the_var tpl_v $-                                mk_tup_sel (chunkify tpl_vs) tpl_v-        where-          tpl_tys = [mkBoxedTupleTy (map idType gp) | gp <- vars_s]-          tpl_vs  = mkTemplateLocals tpl_tys-          [(tpl_v, group)] = [(tpl,gp) | (tpl,gp) <- zipEqual "mkTupleSelector" tpl_vs vars_s,-                                         the_var `elem` gp ]--- ^ 'mkTupleSelector1' is like 'mkTupleSelector'--- but one-tuples are NOT flattened (see Note [Flattening one-tuples])-mkTupleSelector1 vars the_var scrut_var scrut-  | [_] <- vars-  = mkSmallTupleSelector1 vars the_var scrut_var scrut-  | otherwise-  = mkTupleSelector vars the_var scrut_var scrut---- | Like 'mkTupleSelector' but for tuples that are guaranteed--- never to be \"big\".------ > mkSmallTupleSelector [x] x v e = [| e |]--- > mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]-mkSmallTupleSelector, mkSmallTupleSelector1-          :: [Id]        -- The tuple args-          -> Id          -- The selected one-          -> Id          -- A variable of the same type as the scrutinee-          -> CoreExpr    -- Scrutinee-          -> CoreExpr-mkSmallTupleSelector [var] should_be_the_same_var _ scrut-  = ASSERT(var == should_be_the_same_var)-    scrut  -- Special case for 1-tuples-mkSmallTupleSelector vars the_var scrut_var scrut-  = mkSmallTupleSelector1 vars the_var scrut_var scrut---- ^ 'mkSmallTupleSelector1' is like 'mkSmallTupleSelector'--- but one-tuples are NOT flattened (see Note [Flattening one-tuples])-mkSmallTupleSelector1 vars the_var scrut_var scrut-  = ASSERT( notNull vars )-    Case scrut scrut_var (idType the_var)-         [(DataAlt (tupleDataCon Boxed (length vars)), vars, Var the_var)]---- | A generalization of 'mkTupleSelector', allowing the body--- of the case to be an arbitrary expression.------ To avoid shadowing, we use uniques to invent new variables.------ If necessary we pattern match on a \"big\" tuple.-mkTupleCase :: UniqSupply       -- ^ For inventing names of intermediate variables-            -> [Id]             -- ^ The tuple identifiers to pattern match on-            -> CoreExpr         -- ^ Body of the case-            -> Id               -- ^ A variable of the same type as the scrutinee-            -> CoreExpr         -- ^ Scrutinee-            -> CoreExpr--- ToDo: eliminate cases where none of the variables are needed.------         mkTupleCase uniqs [a,b,c,d] body v e---           = case e of v { (p,q) ->---             case p of p { (a,b) ->---             case q of q { (c,d) ->---             body }}}-mkTupleCase uniqs vars body scrut_var scrut-  = mk_tuple_case uniqs (chunkify vars) body-  where-    -- This is the case where don't need any nesting-    mk_tuple_case _ [vars] body-      = mkSmallTupleCase vars body scrut_var scrut--    -- This is the case where we must make nest tuples at least once-    mk_tuple_case us vars_s body-      = let (us', vars', body') = foldr one_tuple_case (us, [], body) vars_s-            in mk_tuple_case us' (chunkify vars') body'--    one_tuple_case chunk_vars (us, vs, body)-      = let (uniq, us') = takeUniqFromSupply us-            scrut_var = mkSysLocal (fsLit "ds") uniq-              (mkBoxedTupleTy (map idType chunk_vars))-            body' = mkSmallTupleCase chunk_vars body scrut_var (Var scrut_var)-        in (us', scrut_var:vs, body')---- | As 'mkTupleCase', but for a tuple that is small enough to be guaranteed--- not to need nesting.-mkSmallTupleCase-        :: [Id]         -- ^ The tuple args-        -> CoreExpr     -- ^ Body of the case-        -> Id           -- ^ A variable of the same type as the scrutinee-        -> CoreExpr     -- ^ Scrutinee-        -> CoreExpr--mkSmallTupleCase [var] body _scrut_var scrut-  = bindNonRec var scrut body-mkSmallTupleCase vars body scrut_var scrut--- One branch no refinement?-  = Case scrut scrut_var (exprType body)-         [(DataAlt (tupleDataCon Boxed (length vars)), vars, body)]--{--************************************************************************-*                                                                      *-                Floats-*                                                                      *-************************************************************************--}--data FloatBind-  = FloatLet  CoreBind-  | FloatCase CoreExpr Id AltCon [Var]-      -- case e of y { C ys -> ... }-      -- See Note [Floating single-alternative cases] in SetLevels--instance Outputable FloatBind where-  ppr (FloatLet b) = text "LET" <+> ppr b-  ppr (FloatCase e b c bs) = hang (text "CASE" <+> ppr e <+> ptext (sLit "of") <+> ppr b)-                                2 (ppr c <+> ppr bs)--wrapFloat :: FloatBind -> CoreExpr -> CoreExpr-wrapFloat (FloatLet defns)       body = Let defns body-wrapFloat (FloatCase e b con bs) body = mkSingleAltCase e b con bs body---- | Applies the floats from right to left. That is @wrapFloats [b1, b2, …, bn]--- u = let b1 in let b2 in … in let bn in u@-wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr-wrapFloats floats expr = foldr wrapFloat expr floats--bindBindings :: CoreBind -> [Var]-bindBindings (NonRec b _) = [b]-bindBindings (Rec bnds) = map fst bnds--floatBindings :: FloatBind -> [Var]-floatBindings (FloatLet bnd) = bindBindings bnd-floatBindings (FloatCase _ b _ bs) = b:bs--{--************************************************************************-*                                                                      *-\subsection{Common list manipulation expressions}-*                                                                      *-************************************************************************--Call the constructor Ids when building explicit lists, so that they-interact well with rules.--}---- | Makes a list @[]@ for lists of the specified type-mkNilExpr :: Type -> CoreExpr-mkNilExpr ty = mkCoreConApps nilDataCon [Type ty]---- | Makes a list @(:)@ for lists of the specified type-mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr-mkConsExpr ty hd tl = mkCoreConApps consDataCon [Type ty, hd, tl]---- | Make a list containing the given expressions, where the list has the given type-mkListExpr :: Type -> [CoreExpr] -> CoreExpr-mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs---- | Make a fully applied 'foldr' expression-mkFoldrExpr :: MonadThings m-            => Type             -- ^ Element type of the list-            -> Type             -- ^ Fold result type-            -> CoreExpr         -- ^ "Cons" function expression for the fold-            -> CoreExpr         -- ^ "Nil" expression for the fold-            -> CoreExpr         -- ^ List expression being folded acress-            -> m CoreExpr-mkFoldrExpr elt_ty result_ty c n list = do-    foldr_id <- lookupId foldrName-    return (Var foldr_id `App` Type elt_ty-           `App` Type result_ty-           `App` c-           `App` n-           `App` list)---- | Make a 'build' expression applied to a locally-bound worker function-mkBuildExpr :: (MonadFail.MonadFail m, MonadThings m, MonadUnique m)-            => Type                                     -- ^ Type of list elements to be built-            -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -- ^ Function that, given information about the 'Id's-                                                        -- of the binders for the build worker function, returns-                                                        -- the body of that worker-            -> m CoreExpr-mkBuildExpr elt_ty mk_build_inside = do-    [n_tyvar] <- newTyVars [alphaTyVar]-    let n_ty = mkTyVarTy n_tyvar-        c_ty = mkVisFunTys [elt_ty, n_ty] n_ty-    [c, n] <- sequence [mkSysLocalM (fsLit "c") c_ty, mkSysLocalM (fsLit "n") n_ty]--    build_inside <- mk_build_inside (c, c_ty) (n, n_ty)--    build_id <- lookupId buildName-    return $ Var build_id `App` Type elt_ty `App` mkLams [n_tyvar, c, n] build_inside-  where-    newTyVars tyvar_tmpls = do-      uniqs <- getUniquesM-      return (zipWith setTyVarUnique tyvar_tmpls uniqs)--{--************************************************************************-*                                                                      *-             Manipulating Maybe data type-*                                                                      *-************************************************************************--}----- | Makes a Nothing for the specified type-mkNothingExpr :: Type -> CoreExpr-mkNothingExpr ty = mkConApp nothingDataCon [Type ty]---- | Makes a Just from a value of the specified type-mkJustExpr :: Type -> CoreExpr -> CoreExpr-mkJustExpr ty val = mkConApp justDataCon [Type ty, val]---{--************************************************************************-*                                                                      *-                      Error expressions-*                                                                      *-************************************************************************--}--mkRuntimeErrorApp-        :: Id           -- Should be of type (forall a. Addr# -> a)-                        --      where Addr# points to a UTF8 encoded string-        -> Type         -- The type to instantiate 'a'-        -> String       -- The string to print-        -> CoreExpr--mkRuntimeErrorApp err_id res_ty err_msg-  = mkApps (Var err_id) [ Type (getRuntimeRep res_ty)-                        , Type res_ty, err_string ]-  where-    err_string = Lit (mkLitString err_msg)--mkImpossibleExpr :: Type -> CoreExpr-mkImpossibleExpr res_ty-  = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty "Impossible case alternative"--{--************************************************************************-*                                                                      *-                     Error Ids-*                                                                      *-************************************************************************--GHC randomly injects these into the code.--@patError@ is just a version of @error@ for pattern-matching-failures.  It knows various ``codes'' which expand to longer-strings---this saves space!--@absentErr@ is a thing we put in for ``absent'' arguments.  They jolly-well shouldn't be yanked on, but if one is, then you will get a-friendly message from @absentErr@ (rather than a totally random-crash).--@parError@ is a special version of @error@ which the compiler does-not know to be a bottoming Id.  It is used in the @_par_@ and @_seq_@-templates, but we don't ever expect to generate code for it.--}--errorIds :: [Id]-errorIds-  = [ rUNTIME_ERROR_ID,-      nON_EXHAUSTIVE_GUARDS_ERROR_ID,-      nO_METHOD_BINDING_ERROR_ID,-      pAT_ERROR_ID,-      rEC_CON_ERROR_ID,-      rEC_SEL_ERROR_ID,-      aBSENT_ERROR_ID,-      tYPE_ERROR_ID   -- Used with Opt_DeferTypeErrors, see #10284-      ]--recSelErrorName, runtimeErrorName, absentErrorName :: Name-recConErrorName, patErrorName :: Name-nonExhaustiveGuardsErrorName, noMethodBindingErrorName :: Name-typeErrorName :: Name-absentSumFieldErrorName :: Name--recSelErrorName     = err_nm "recSelError"     recSelErrorIdKey     rEC_SEL_ERROR_ID-absentErrorName     = err_nm "absentError"     absentErrorIdKey     aBSENT_ERROR_ID-absentSumFieldErrorName = err_nm "absentSumFieldError"  absentSumFieldErrorIdKey-                            aBSENT_SUM_FIELD_ERROR_ID-runtimeErrorName    = err_nm "runtimeError"    runtimeErrorIdKey    rUNTIME_ERROR_ID-recConErrorName     = err_nm "recConError"     recConErrorIdKey     rEC_CON_ERROR_ID-patErrorName        = err_nm "patError"        patErrorIdKey        pAT_ERROR_ID-typeErrorName       = err_nm "typeError"       typeErrorIdKey       tYPE_ERROR_ID--noMethodBindingErrorName     = err_nm "noMethodBindingError"-                                  noMethodBindingErrorIdKey nO_METHOD_BINDING_ERROR_ID-nonExhaustiveGuardsErrorName = err_nm "nonExhaustiveGuardsError"-                                  nonExhaustiveGuardsErrorIdKey nON_EXHAUSTIVE_GUARDS_ERROR_ID--err_nm :: String -> Unique -> Id -> Name-err_nm str uniq id = mkWiredInIdName cONTROL_EXCEPTION_BASE (fsLit str) uniq id--rEC_SEL_ERROR_ID, rUNTIME_ERROR_ID, rEC_CON_ERROR_ID :: Id-pAT_ERROR_ID, nO_METHOD_BINDING_ERROR_ID, nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id-tYPE_ERROR_ID, aBSENT_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID :: Id-rEC_SEL_ERROR_ID                = mkRuntimeErrorId recSelErrorName-rUNTIME_ERROR_ID                = mkRuntimeErrorId runtimeErrorName-rEC_CON_ERROR_ID                = mkRuntimeErrorId recConErrorName-pAT_ERROR_ID                    = mkRuntimeErrorId patErrorName-nO_METHOD_BINDING_ERROR_ID      = mkRuntimeErrorId noMethodBindingErrorName-nON_EXHAUSTIVE_GUARDS_ERROR_ID  = mkRuntimeErrorId nonExhaustiveGuardsErrorName-tYPE_ERROR_ID                   = mkRuntimeErrorId typeErrorName---- Note [aBSENT_SUM_FIELD_ERROR_ID]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- Absent argument error for unused unboxed sum fields are different than absent--- error used in dummy worker functions (see `mkAbsentErrorApp`):------ - `absentSumFieldError` can't take arguments because it's used in unarise for---   unused pointer fields in unboxed sums, and applying an argument would---   require allocating a thunk.------ - `absentSumFieldError` can't be CAFFY because that would mean making some---   non-CAFFY definitions that use unboxed sums CAFFY in unarise.------   To make `absentSumFieldError` non-CAFFY we get a stable pointer to it in---   RtsStartup.c and mark it as non-CAFFY here.------ Getting this wrong causes hard-to-debug runtime issues, see #15038.------ TODO: Remove stable pointer hack after fixing #9718.---       However, we should still be careful about not making things CAFFY just---       because they use unboxed sums. Unboxed objects are supposed to be---       efficient, and none of the other unboxed literals make things CAFFY.--aBSENT_SUM_FIELD_ERROR_ID-  = mkVanillaGlobalWithInfo absentSumFieldErrorName-      (mkSpecForAllTys [alphaTyVar] (mkTyVarTy alphaTyVar)) -- forall a . a-      (vanillaIdInfo `setStrictnessInfo` mkClosedStrictSig [] botRes-                     `setArityInfo` 0-                     `setCafInfo` NoCafRefs) -- #15038--mkRuntimeErrorId :: Name -> Id--- Error function---   with type:  forall (r:RuntimeRep) (a:TYPE r). Addr# -> a---   with arity: 1--- which diverges after being given one argument--- The Addr# is expected to be the address of---   a UTF8-encoded error string-mkRuntimeErrorId name- = mkVanillaGlobalWithInfo name runtimeErrorTy bottoming_info- where-    bottoming_info = vanillaIdInfo `setStrictnessInfo`    strict_sig-                                   `setArityInfo`         1-                        -- Make arity and strictness agree--        -- Do *not* mark them as NoCafRefs, because they can indeed have-        -- CAF refs.  For example, pAT_ERROR_ID calls GHC.Err.untangle,-        -- which has some CAFs-        -- In due course we may arrange that these error-y things are-        -- regarded by the GC as permanently live, in which case we-        -- can give them NoCaf info.  As it is, any function that calls-        -- any pc_bottoming_Id will itself have CafRefs, which bloats-        -- SRTs.--    strict_sig = mkClosedStrictSig [evalDmd] botRes--runtimeErrorTy :: Type--- forall (rr :: RuntimeRep) (a :: rr). Addr# -> a---   See Note [Error and friends have an "open-tyvar" forall]-runtimeErrorTy = mkSpecForAllTys [runtimeRep1TyVar, openAlphaTyVar]-                                 (mkVisFunTy addrPrimTy openAlphaTy)--{- Note [Error and friends have an "open-tyvar" forall]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-'error' and 'undefined' have types-        error     :: forall (v :: RuntimeRep) (a :: TYPE v). String -> a-        undefined :: forall (v :: RuntimeRep) (a :: TYPE v). a-Notice the runtime-representation polymorphism. This ensures that-"error" can be instantiated at unboxed as well as boxed types.-This is OK because it never returns, so the return type is irrelevant.---************************************************************************-*                                                                      *-                     aBSENT_ERROR_ID-*                                                                      *-************************************************************************--Note [aBSENT_ERROR_ID]-~~~~~~~~~~~~~~~~~~~~~~-We use aBSENT_ERROR_ID to build dummy values in workers.  E.g.--   f x = (case x of (a,b) -> b) + 1::Int--The demand analyser figures ot that only the second component of x is-used, and does a w/w split thus--   f x = case x of (a,b) -> $wf b--   $wf b = let a = absentError "blah"-               x = (a,b)-           in <the original RHS of f>--After some simplification, the (absentError "blah") thunk goes away.-------- Tricky wrinkle --------#14285 had, roughly--   data T a = MkT a !a-   {-# INLINABLE f #-}-   f x = case x of MkT a b -> g (MkT b a)--It turned out that g didn't use the second component, and hence f doesn't use-the first.  But the stable-unfolding for f looks like-   \x. case x of MkT a b -> g ($WMkT b a)-where $WMkT is the wrapper for MkT that evaluates its arguments.  We-apply the same w/w split to this unfolding (see Note [Worker-wrapper-for INLINEABLE functions] in WorkWrap) so the template ends up like-   \b. let a = absentError "blah"-           x = MkT a b-        in case x of MkT a b -> g ($WMkT b a)--After doing case-of-known-constructor, and expanding $WMkT we get-   \b -> g (case absentError "blah" of a -> MkT b a)--Yikes!  That bogusly appears to evaluate the absentError!--This is extremely tiresome.  Another way to think of this is that, in-Core, it is an invariant that a strict data constructor, like MkT, must-be applied only to an argument in HNF. So (absentError "blah") had-better be non-bottom.--So the "solution" is to add a special case for absentError to exprIsHNFlike.-This allows Simplify.rebuildCase, in the Note [Case to let transformation]-branch, to convert the case on absentError into a let. We also make-absentError *not* be diverging, unlike the other error-ids, so that we-can be sure not to remove the case branches before converting the case to-a let.--If, by some bug or bizarre happenstance, we ever call absentError, we should-throw an exception.  This should never happen, of course, but we definitely-can't return anything.  e.g. if somehow we had-    case absentError "foo" of-       Nothing -> ...-       Just x  -> ...-then if we return, the case expression will select a field and continue.-Seg fault city. Better to throw an exception. (Even though we've said-it is in HNF :-)--It might seem a bit surprising that seq on absentError is simply erased--    absentError "foo" `seq` x ==> x--but that should be okay; since there's no pattern match we can't really-be relying on anything from it.--}--aBSENT_ERROR_ID- = mkVanillaGlobalWithInfo absentErrorName absent_ty arity_info- where-   absent_ty = mkSpecForAllTys [alphaTyVar] (mkVisFunTy addrPrimTy alphaTy)-   -- Not runtime-rep polymorphic. aBSENT_ERROR_ID is only used for-   -- lifted-type things; see Note [Absent errors] in WwLib-   arity_info = vanillaIdInfo `setArityInfo` 1-   -- NB: no bottoming strictness info, unlike other error-ids.-   -- See Note [aBSENT_ERROR_ID]--mkAbsentErrorApp :: Type         -- The type to instantiate 'a'-                 -> String       -- The string to print-                 -> CoreExpr--mkAbsentErrorApp res_ty err_msg-  = mkApps (Var aBSENT_ERROR_ID) [ Type res_ty, err_string ]-  where-    err_string = Lit (mkLitString err_msg)

− compiler/coreSyn/PprCore.hs

@@ -1,620 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The AQUA Project, Glasgow University, 1996-1998---Printing of Core syntax--}--{-# LANGUAGE MultiWayIf #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}-module PprCore (-        pprCoreExpr, pprParendExpr,-        pprCoreBinding, pprCoreBindings, pprCoreAlt,-        pprCoreBindingWithSize, pprCoreBindingsWithSize,-        pprRules, pprOptCo-    ) where--import GhcPrelude--import CoreSyn-import CoreStats (exprStats)-import Literal( pprLiteral )-import Name( pprInfixName, pprPrefixName )-import Var-import Id-import IdInfo-import Demand-import DataCon-import TyCon-import TyCoPpr-import Coercion-import DynFlags-import BasicTypes-import Maybes-import Util-import Outputable-import FastString-import SrcLoc      ( pprUserRealSpan )--{--************************************************************************-*                                                                      *-\subsection{Public interfaces for Core printing (excluding instances)}-*                                                                      *-************************************************************************--@pprParendCoreExpr@ puts parens around non-atomic Core expressions.--}--pprCoreBindings :: OutputableBndr b => [Bind b] -> SDoc-pprCoreBinding  :: OutputableBndr b => Bind b  -> SDoc-pprCoreExpr     :: OutputableBndr b => Expr b  -> SDoc-pprParendExpr   :: OutputableBndr b => Expr b  -> SDoc--pprCoreBindings = pprTopBinds noAnn-pprCoreBinding  = pprTopBind noAnn--pprCoreBindingsWithSize :: [CoreBind] -> SDoc-pprCoreBindingWithSize  :: CoreBind  -> SDoc--pprCoreBindingsWithSize = pprTopBinds sizeAnn-pprCoreBindingWithSize = pprTopBind sizeAnn--instance OutputableBndr b => Outputable (Bind b) where-    ppr bind = ppr_bind noAnn bind--instance OutputableBndr b => Outputable (Expr b) where-    ppr expr = pprCoreExpr expr--{--************************************************************************-*                                                                      *-\subsection{The guts}-*                                                                      *-************************************************************************--}---- | A function to produce an annotation for a given right-hand-side-type Annotation b = Expr b -> SDoc---- | Annotate with the size of the right-hand-side-sizeAnn :: CoreExpr -> SDoc-sizeAnn e = text "-- RHS size:" <+> ppr (exprStats e)---- | No annotation-noAnn :: Expr b -> SDoc-noAnn _ = empty--pprTopBinds :: OutputableBndr a-            => Annotation a -- ^ generate an annotation to place before the-                            -- binding-            -> [Bind a]     -- ^ bindings to show-            -> SDoc         -- ^ the pretty result-pprTopBinds ann binds = vcat (map (pprTopBind ann) binds)--pprTopBind :: OutputableBndr a => Annotation a -> Bind a -> SDoc-pprTopBind ann (NonRec binder expr)- = ppr_binding ann (binder,expr) $$ blankLine--pprTopBind _ (Rec [])-  = text "Rec { }"-pprTopBind ann (Rec (b:bs))-  = vcat [text "Rec {",-          ppr_binding ann b,-          vcat [blankLine $$ ppr_binding ann b | b <- bs],-          text "end Rec }",-          blankLine]--ppr_bind :: OutputableBndr b => Annotation b -> Bind b -> SDoc--ppr_bind ann (NonRec val_bdr expr) = ppr_binding ann (val_bdr, expr)-ppr_bind ann (Rec binds)           = vcat (map pp binds)-                                    where-                                      pp bind = ppr_binding ann bind <> semi--ppr_binding :: OutputableBndr b => Annotation b -> (b, Expr b) -> SDoc-ppr_binding ann (val_bdr, expr)-  = sdocWithDynFlags $ \dflags ->-      vcat [ ann expr-           , if gopt Opt_SuppressTypeSignatures dflags-               then empty-               else pprBndr LetBind val_bdr-           , pp_bind-           ]-  where-    pp_bind = case bndrIsJoin_maybe val_bdr of-                Nothing -> pp_normal_bind-                Just ar -> pp_join_bind ar--    pp_normal_bind = hang (ppr val_bdr) 2 (equals <+> pprCoreExpr expr)--      -- For a join point of join arity n, we want to print j = \x1 ... xn -> e-      -- as "j x1 ... xn = e" to differentiate when a join point returns a-      -- lambda (the first rendering looks like a nullary join point returning-      -- an n-argument function).-    pp_join_bind join_arity-      | bndrs `lengthAtLeast` join_arity-      = hang (ppr val_bdr <+> sep (map (pprBndr LambdaBind) lhs_bndrs))-           2 (equals <+> pprCoreExpr rhs)-      | otherwise -- Yikes!  A join-binding with too few lambda-                  -- Lint will complain, but we don't want to crash-                  -- the pretty-printer else we can't see what's wrong-                  -- So refer to printing  j = e-      = pp_normal_bind-      where-        (bndrs, body) = collectBinders expr-        lhs_bndrs = take join_arity bndrs-        rhs       = mkLams (drop join_arity bndrs) body--pprParendExpr expr = ppr_expr parens expr-pprCoreExpr   expr = ppr_expr noParens expr--noParens :: SDoc -> SDoc-noParens pp = pp--pprOptCo :: Coercion -> SDoc--- Print a coercion optionally; i.e. honouring -dsuppress-coercions-pprOptCo co = sdocWithDynFlags $ \dflags ->-              if gopt Opt_SuppressCoercions dflags-              then angleBrackets (text "Co:" <> int (coercionSize co))-              else parens (sep [ppr co, dcolon <+> ppr (coercionType co)])--ppr_expr :: OutputableBndr b => (SDoc -> SDoc) -> Expr b -> SDoc-        -- The function adds parens in context that need-        -- an atomic value (e.g. function args)--ppr_expr add_par (Var name)- | isJoinId name               = add_par ((text "jump") <+> ppr name)- | otherwise                   = ppr name-ppr_expr add_par (Type ty)     = add_par (text "TYPE:" <+> ppr ty)       -- Weird-ppr_expr add_par (Coercion co) = add_par (text "CO:" <+> ppr co)-ppr_expr add_par (Lit lit)     = pprLiteral add_par lit--ppr_expr add_par (Cast expr co)-  = add_par $ sep [pprParendExpr expr, text "`cast`" <+> pprOptCo co]--ppr_expr add_par expr@(Lam _ _)-  = let-        (bndrs, body) = collectBinders expr-    in-    add_par $-    hang (text "\\" <+> sep (map (pprBndr LambdaBind) bndrs) <+> arrow)-         2 (pprCoreExpr body)--ppr_expr add_par expr@(App {})-  = sdocWithDynFlags $ \dflags ->-    case collectArgs expr of { (fun, args) ->-    let-        pp_args     = sep (map pprArg args)-        val_args    = dropWhile isTypeArg args   -- Drop the type arguments for tuples-        pp_tup_args = pprWithCommas pprCoreExpr val_args-        args'-          | gopt Opt_SuppressTypeApplications dflags = val_args-          | otherwise = args-        parens-          | null args' = id-          | otherwise  = add_par-    in-    case fun of-        Var f -> case isDataConWorkId_maybe f of-                        -- Notice that we print the *worker*-                        -- for tuples in paren'd format.-                   Just dc | saturated-                           , Just sort <- tyConTuple_maybe tc-                           -> tupleParens sort pp_tup_args-                           where-                             tc        = dataConTyCon dc-                             saturated = val_args `lengthIs` idArity f--                   _ -> parens (hang fun_doc 2 pp_args)-                   where-                     fun_doc | isJoinId f = text "jump" <+> ppr f-                             | otherwise  = ppr f--        _ -> parens (hang (pprParendExpr fun) 2 pp_args)-    }--ppr_expr add_par (Case expr var ty [(con,args,rhs)])-  = sdocWithDynFlags $ \dflags ->-    if gopt Opt_PprCaseAsLet dflags-    then add_par $  -- See Note [Print case as let]-         sep [ sep [ text "let! {"-                     <+> ppr_case_pat con args-                     <+> text "~"-                     <+> ppr_bndr var-                   , text "<-" <+> ppr_expr id expr-                     <+> text "} in" ]-             , pprCoreExpr rhs-             ]-    else add_par $-         sep [sep [sep [ text "case" <+> pprCoreExpr expr-                       , whenPprDebug (text "return" <+> ppr ty)-                       , text "of" <+> ppr_bndr var-                       ]-                  , char '{' <+> ppr_case_pat con args <+> arrow-                  ]-              , pprCoreExpr rhs-              , char '}'-              ]-  where-    ppr_bndr = pprBndr CaseBind--ppr_expr add_par (Case expr var ty alts)-  = add_par $-    sep [sep [text "case"-                <+> pprCoreExpr expr-                <+> whenPprDebug (text "return" <+> ppr ty),-              text "of" <+> ppr_bndr var <+> char '{'],-         nest 2 (vcat (punctuate semi (map pprCoreAlt alts))),-         char '}'-    ]-  where-    ppr_bndr = pprBndr CaseBind----- special cases: let ... in let ...--- ("disgusting" SLPJ)--{--ppr_expr add_par (Let bind@(NonRec val_bdr rhs@(Let _ _)) body)-  = add_par $-    vcat [-      hsep [text "let {", (pprBndr LetBind val_bdr $$ ppr val_bndr), equals],-      nest 2 (pprCoreExpr rhs),-      text "} in",-      pprCoreExpr body ]--ppr_expr add_par (Let bind@(NonRec val_bdr rhs) expr@(Let _ _))-  = add_par-    (hang (text "let {")-          2 (hsep [ppr_binding (val_bdr,rhs),-                   text "} in"])-     $$-     pprCoreExpr expr)--}----- General case (recursive case, too)-ppr_expr add_par (Let bind expr)-  = add_par $-    sep [hang (keyword bind <+> char '{') 2 (ppr_bind noAnn bind <+> text "} in"),-         pprCoreExpr expr]-  where-    keyword (NonRec b _)-     | isJust (bndrIsJoin_maybe b) = text "join"-     | otherwise                   = text "let"-    keyword (Rec pairs)-     | ((b,_):_) <- pairs-     , isJust (bndrIsJoin_maybe b) = text "joinrec"-     | otherwise                   = text "letrec"--ppr_expr add_par (Tick tickish expr)-  = sdocWithDynFlags $ \dflags ->-  if gopt Opt_SuppressTicks dflags-  then ppr_expr add_par expr-  else add_par (sep [ppr tickish, pprCoreExpr expr])--pprCoreAlt :: OutputableBndr a => (AltCon, [a] , Expr a) -> SDoc-pprCoreAlt (con, args, rhs)-  = hang (ppr_case_pat con args <+> arrow) 2 (pprCoreExpr rhs)--ppr_case_pat :: OutputableBndr a => AltCon -> [a] -> SDoc-ppr_case_pat (DataAlt dc) args-  | Just sort <- tyConTuple_maybe tc-  = tupleParens sort (pprWithCommas ppr_bndr args)-  where-    ppr_bndr = pprBndr CasePatBind-    tc = dataConTyCon dc--ppr_case_pat con args-  = ppr con <+> (fsep (map ppr_bndr args))-  where-    ppr_bndr = pprBndr CasePatBind----- | Pretty print the argument in a function application.-pprArg :: OutputableBndr a => Expr a -> SDoc-pprArg (Type ty)- = sdocWithDynFlags $ \dflags ->-   if gopt Opt_SuppressTypeApplications dflags-   then empty-   else text "@" <> pprParendType ty-pprArg (Coercion co) = text "@~" <> pprOptCo co-pprArg expr          = pprParendExpr expr--{--Note [Print case as let]-~~~~~~~~~~~~~~~~~~~~~~~~-Single-branch case expressions are very common:-   case x of y { I# x' ->-   case p of q { I# p' -> ... } }-These are, in effect, just strict let's, with pattern matching.-With -dppr-case-as-let we print them as such:-   let! { I# x' ~ y <- x } in-   let! { I# p' ~ q <- p } in ...---Other printing bits-and-bobs used with the general @pprCoreBinding@-and @pprCoreExpr@ functions.---Note [Binding-site specific printing]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--pprCoreBinder and pprTypedLamBinder receive a BindingSite argument to adjust-the information printed.--Let-bound binders are printed with their full type and idInfo.--Case-bound variables (both the case binder and pattern variables) are printed-without a type and without their unfolding.--Furthermore, a dead case-binder is completely ignored, while otherwise, dead-binders are printed as "_".--}---- These instances are sadly orphans--instance OutputableBndr Var where-  pprBndr = pprCoreBinder-  pprInfixOcc  = pprInfixName  . varName-  pprPrefixOcc = pprPrefixName . varName-  bndrIsJoin_maybe = isJoinId_maybe--instance Outputable b => OutputableBndr (TaggedBndr b) where-  pprBndr _    b = ppr b   -- Simple-  pprInfixOcc  b = ppr b-  pprPrefixOcc b = ppr b-  bndrIsJoin_maybe (TB b _) = isJoinId_maybe b--pprCoreBinder :: BindingSite -> Var -> SDoc-pprCoreBinder LetBind binder-  | isTyVar binder = pprKindedTyVarBndr binder-  | otherwise      = pprTypedLetBinder binder $$-                     ppIdInfo binder (idInfo binder)---- Lambda bound type variables are preceded by "@"-pprCoreBinder bind_site bndr-  = getPprStyle $ \ sty ->-    pprTypedLamBinder bind_site (debugStyle sty) bndr--pprUntypedBinder :: Var -> SDoc-pprUntypedBinder binder-  | isTyVar binder = text "@" <> ppr binder    -- NB: don't print kind-  | otherwise      = pprIdBndr binder--pprTypedLamBinder :: BindingSite -> Bool -> Var -> SDoc--- For lambda and case binders, show the unfolding info (usually none)-pprTypedLamBinder bind_site debug_on var-  = sdocWithDynFlags $ \dflags ->-    case () of-    _-      | not debug_on            -- Show case-bound wild binders only if debug is on-      , CaseBind <- bind_site-      , isDeadBinder var        -> empty--      | not debug_on            -- Even dead binders can be one-shot-      , isDeadBinder var        -> char '_' <+> ppWhen (isId var)-                                                (pprIdBndrInfo (idInfo var))--      | not debug_on            -- No parens, no kind info-      , CaseBind <- bind_site   -> pprUntypedBinder var--      | not debug_on-      , CasePatBind <- bind_site    -> pprUntypedBinder var--      | suppress_sigs dflags    -> pprUntypedBinder var--      | isTyVar var  -> parens (pprKindedTyVarBndr var)--      | otherwise    -> parens (hang (pprIdBndr var)-                                   2 (vcat [ dcolon <+> pprType (idType var)-                                           , pp_unf]))-  where-    suppress_sigs = gopt Opt_SuppressTypeSignatures--    unf_info = unfoldingInfo (idInfo var)-    pp_unf | hasSomeUnfolding unf_info = text "Unf=" <> ppr unf_info-           | otherwise                 = empty--pprTypedLetBinder :: Var -> SDoc--- Print binder with a type or kind signature (not paren'd)-pprTypedLetBinder binder-  = sdocWithDynFlags $ \dflags ->-    case () of-    _-      | isTyVar binder                         -> pprKindedTyVarBndr binder-      | gopt Opt_SuppressTypeSignatures dflags -> pprIdBndr binder-      | otherwise                              -> hang (pprIdBndr binder) 2 (dcolon <+> pprType (idType binder))--pprKindedTyVarBndr :: TyVar -> SDoc--- Print a type variable binder with its kind (but not if *)-pprKindedTyVarBndr tyvar-  = text "@" <> pprTyVar tyvar---- pprIdBndr does *not* print the type--- When printing any Id binder in debug mode, we print its inline pragma and one-shot-ness-pprIdBndr :: Id -> SDoc-pprIdBndr id = ppr id <+> pprIdBndrInfo (idInfo id)--pprIdBndrInfo :: IdInfo -> SDoc-pprIdBndrInfo info-  = sdocWithDynFlags $ \dflags ->-    ppUnless (gopt Opt_SuppressIdInfo dflags) $-    info `seq` doc -- The seq is useful for poking on black holes-  where-    prag_info = inlinePragInfo info-    occ_info  = occInfo info-    dmd_info  = demandInfo info-    lbv_info  = oneShotInfo info--    has_prag  = not (isDefaultInlinePragma prag_info)-    has_occ   = not (isManyOccs occ_info)-    has_dmd   = not $ isTopDmd dmd_info-    has_lbv   = not (hasNoOneShotInfo lbv_info)--    doc = showAttributes-          [ (has_prag, text "InlPrag=" <> pprInlineDebug prag_info)-          , (has_occ,  text "Occ=" <> ppr occ_info)-          , (has_dmd,  text "Dmd=" <> ppr dmd_info)-          , (has_lbv , text "OS=" <> ppr lbv_info)-          ]--{----------------------------------------------------------      IdDetails and IdInfo--------------------------------------------------------}--ppIdInfo :: Id -> IdInfo -> SDoc-ppIdInfo id info-  = sdocWithDynFlags $ \dflags ->-    ppUnless (gopt Opt_SuppressIdInfo dflags) $-    showAttributes-    [ (True, pp_scope <> ppr (idDetails id))-    , (has_arity,        text "Arity=" <> int arity)-    , (has_called_arity, text "CallArity=" <> int called_arity)-    , (has_caf_info,     text "Caf=" <> ppr caf_info)-    , (has_str_info,     text "Str=" <> pprStrictness str_info)-    , (has_unf,          text "Unf=" <> ppr unf_info)-    , (not (null rules), text "RULES:" <+> vcat (map pprRule rules))-    ]   -- Inline pragma, occ, demand, one-shot info-        -- printed out with all binders (when debug is on);-        -- see PprCore.pprIdBndr-  where-    pp_scope | isGlobalId id   = text "GblId"-             | isExportedId id = text "LclIdX"-             | otherwise       = text "LclId"--    arity = arityInfo info-    has_arity = arity /= 0--    called_arity = callArityInfo info-    has_called_arity = called_arity /= 0--    caf_info = cafInfo info-    has_caf_info = not (mayHaveCafRefs caf_info)--    str_info = strictnessInfo info-    has_str_info = not (isTopSig str_info)--    unf_info = unfoldingInfo info-    has_unf = hasSomeUnfolding unf_info--    rules = ruleInfoRules (ruleInfo info)--showAttributes :: [(Bool,SDoc)] -> SDoc-showAttributes stuff-  | null docs = empty-  | otherwise = brackets (sep (punctuate comma docs))-  where-    docs = [d | (True,d) <- stuff]--{----------------------------------------------------------      Unfolding and UnfoldingGuidance--------------------------------------------------------}--instance Outputable UnfoldingGuidance where-    ppr UnfNever  = text "NEVER"-    ppr (UnfWhen { ug_arity = arity, ug_unsat_ok = unsat_ok, ug_boring_ok = boring_ok })-      = text "ALWAYS_IF" <>-        parens (text "arity="     <> int arity    <> comma <>-                text "unsat_ok="  <> ppr unsat_ok <> comma <>-                text "boring_ok=" <> ppr boring_ok)-    ppr (UnfIfGoodArgs { ug_args = cs, ug_size = size, ug_res = discount })-      = hsep [ text "IF_ARGS",-               brackets (hsep (map int cs)),-               int size,-               int discount ]--instance Outputable UnfoldingSource where-  ppr InlineCompulsory  = text "Compulsory"-  ppr InlineStable      = text "InlineStable"-  ppr InlineRhs         = text "<vanilla>"--instance Outputable Unfolding where-  ppr NoUnfolding                = text "No unfolding"-  ppr BootUnfolding              = text "No unfolding (from boot)"-  ppr (OtherCon cs)              = text "OtherCon" <+> ppr cs-  ppr (DFunUnfolding { df_bndrs = bndrs, df_con = con, df_args = args })-       = hang (text "DFun:" <+> ptext (sLit "\\")-                <+> sep (map (pprBndr LambdaBind) bndrs) <+> arrow)-            2 (ppr con <+> sep (map ppr args))-  ppr (CoreUnfolding { uf_src = src-                     , uf_tmpl=rhs, uf_is_top=top, uf_is_value=hnf-                     , uf_is_conlike=conlike, uf_is_work_free=wf-                     , uf_expandable=exp, uf_guidance=g })-        = text "Unf" <> braces (pp_info $$ pp_rhs)-    where-      pp_info = fsep $ punctuate comma-                [ text "Src="        <> ppr src-                , text "TopLvl="     <> ppr top-                , text "Value="      <> ppr hnf-                , text "ConLike="    <> ppr conlike-                , text "WorkFree="   <> ppr wf-                , text "Expandable=" <> ppr exp-                , text "Guidance="   <> ppr g ]-      pp_tmpl = sdocWithDynFlags $ \dflags ->-                ppUnless (gopt Opt_SuppressUnfoldings dflags) $-                text "Tmpl=" <+> ppr rhs-      pp_rhs | isStableSource src = pp_tmpl-             | otherwise          = empty-            -- Don't print the RHS or we get a quadratic-            -- blowup in the size of the printout!--{----------------------------------------------------------      Rules--------------------------------------------------------}--instance Outputable CoreRule where-   ppr = pprRule--pprRules :: [CoreRule] -> SDoc-pprRules rules = vcat (map pprRule rules)--pprRule :: CoreRule -> SDoc-pprRule (BuiltinRule { ru_fn = fn, ru_name = name})-  = text "Built in rule for" <+> ppr fn <> colon <+> doubleQuotes (ftext name)--pprRule (Rule { ru_name = name, ru_act = act, ru_fn = fn,-                ru_bndrs = tpl_vars, ru_args = tpl_args,-                ru_rhs = rhs })-  = hang (doubleQuotes (ftext name) <+> ppr act)-       4 (sep [text "forall" <+>-                  sep (map (pprCoreBinder LambdaBind) tpl_vars) <> dot,-               nest 2 (ppr fn <+> sep (map pprArg tpl_args)),-               nest 2 (text "=" <+> pprCoreExpr rhs)-            ])--{----------------------------------------------------------      Tickish--------------------------------------------------------}--instance Outputable id => Outputable (Tickish id) where-  ppr (HpcTick modl ix) =-      hcat [text "hpc<",-            ppr modl, comma,-            ppr ix,-            text ">"]-  ppr (Breakpoint ix vars) =-      hcat [text "break<",-            ppr ix,-            text ">",-            parens (hcat (punctuate comma (map ppr vars)))]-  ppr (ProfNote { profNoteCC = cc,-                  profNoteCount = tick,-                  profNoteScope = scope }) =-      case (tick,scope) of-         (True,True)  -> hcat [text "scctick<", ppr cc, char '>']-         (True,False) -> hcat [text "tick<",    ppr cc, char '>']-         _            -> hcat [text "scc<",     ppr cc, char '>']-  ppr (SourceNote span _) =-      hcat [ text "src<", pprUserRealSpan True span, char '>']-

− compiler/ghci/ByteCodeTypes.hs

@@ -1,182 +0,0 @@-{-# LANGUAGE MagicHash, RecordWildCards, GeneralizedNewtypeDeriving #-}------  (c) The University of Glasgow 2002-2006------- | Bytecode assembler types-module ByteCodeTypes-  ( CompiledByteCode(..), seqCompiledByteCode, FFIInfo(..)-  , UnlinkedBCO(..), BCOPtr(..), BCONPtr(..)-  , ItblEnv, ItblPtr(..)-  , CgBreakInfo(..)-  , ModBreaks (..), BreakIndex, emptyModBreaks-  , CCostCentre-  ) where--import GhcPrelude--import FastString-import Id-import Name-import NameEnv-import Outputable-import PrimOp-import SizedSeq-import Type-import SrcLoc-import GHCi.BreakArray-import GHCi.RemoteTypes-import GHCi.FFI-import Control.DeepSeq--import Foreign-import Data.Array-import Data.Array.Base  ( UArray(..) )-import Data.ByteString (ByteString)-import Data.IntMap (IntMap)-import qualified Data.IntMap as IntMap-import Data.Maybe (catMaybes)-import GHC.Exts.Heap-import GHC.Stack.CCS---- -------------------------------------------------------------------------------- Compiled Byte Code--data CompiledByteCode = CompiledByteCode-  { bc_bcos   :: [UnlinkedBCO]  -- Bunch of interpretable bindings-  , bc_itbls  :: ItblEnv        -- A mapping from DataCons to their itbls-  , bc_ffis   :: [FFIInfo]      -- ffi blocks we allocated-  , bc_strs   :: [RemotePtr ()] -- malloc'd strings-  , bc_breaks :: Maybe ModBreaks -- breakpoint info (Nothing if we're not-                                 -- creating breakpoints, for some reason)-  }-                -- ToDo: we're not tracking strings that we malloc'd-newtype FFIInfo = FFIInfo (RemotePtr C_ffi_cif)-  deriving (Show, NFData)--instance Outputable CompiledByteCode where-  ppr CompiledByteCode{..} = ppr bc_bcos---- Not a real NFData instance, because ModBreaks contains some things--- we can't rnf-seqCompiledByteCode :: CompiledByteCode -> ()-seqCompiledByteCode CompiledByteCode{..} =-  rnf bc_bcos `seq`-  rnf (nameEnvElts bc_itbls) `seq`-  rnf bc_ffis `seq`-  rnf bc_strs `seq`-  rnf (fmap seqModBreaks bc_breaks)--type ItblEnv = NameEnv (Name, ItblPtr)-        -- We need the Name in the range so we know which-        -- elements to filter out when unloading a module--newtype ItblPtr = ItblPtr (RemotePtr StgInfoTable)-  deriving (Show, NFData)--data UnlinkedBCO-   = UnlinkedBCO {-        unlinkedBCOName   :: !Name,-        unlinkedBCOArity  :: {-# UNPACK #-} !Int,-        unlinkedBCOInstrs :: !(UArray Int Word16),      -- insns-        unlinkedBCOBitmap :: !(UArray Int Word64),      -- bitmap-        unlinkedBCOLits   :: !(SizedSeq BCONPtr),       -- non-ptrs-        unlinkedBCOPtrs   :: !(SizedSeq BCOPtr)         -- ptrs-   }--instance NFData UnlinkedBCO where-  rnf UnlinkedBCO{..} =-    rnf unlinkedBCOLits `seq`-    rnf unlinkedBCOPtrs--data BCOPtr-  = BCOPtrName   !Name-  | BCOPtrPrimOp !PrimOp-  | BCOPtrBCO    !UnlinkedBCO-  | BCOPtrBreakArray  -- a pointer to this module's BreakArray--instance NFData BCOPtr where-  rnf (BCOPtrBCO bco) = rnf bco-  rnf x = x `seq` ()--data BCONPtr-  = BCONPtrWord  {-# UNPACK #-} !Word-  | BCONPtrLbl   !FastString-  | BCONPtrItbl  !Name-  | BCONPtrStr   !ByteString--instance NFData BCONPtr where-  rnf x = x `seq` ()---- | Information about a breakpoint that we know at code-generation time-data CgBreakInfo-   = CgBreakInfo-   { cgb_vars   :: [Maybe (Id,Word16)]-   , cgb_resty  :: Type-   }--- See Note [Syncing breakpoint info] in compiler/main/InteractiveEval.hs---- Not a real NFData instance because we can't rnf Id or Type-seqCgBreakInfo :: CgBreakInfo -> ()-seqCgBreakInfo CgBreakInfo{..} =-  rnf (map snd (catMaybes (cgb_vars))) `seq`-  seqType cgb_resty--instance Outputable UnlinkedBCO where-   ppr (UnlinkedBCO nm _arity _insns _bitmap lits ptrs)-      = sep [text "BCO", ppr nm, text "with",-             ppr (sizeSS lits), text "lits",-             ppr (sizeSS ptrs), text "ptrs" ]--instance Outputable CgBreakInfo where-   ppr info = text "CgBreakInfo" <+>-              parens (ppr (cgb_vars info) <+>-                      ppr (cgb_resty info))---- -------------------------------------------------------------------------------- Breakpoints---- | Breakpoint index-type BreakIndex = Int---- | C CostCentre type-data CCostCentre---- | All the information about the breakpoints for a module-data ModBreaks-   = ModBreaks-   { modBreaks_flags :: ForeignRef BreakArray-        -- ^ The array of flags, one per breakpoint,-        -- indicating which breakpoints are enabled.-   , modBreaks_locs :: !(Array BreakIndex SrcSpan)-        -- ^ An array giving the source span of each breakpoint.-   , modBreaks_vars :: !(Array BreakIndex [OccName])-        -- ^ An array giving the names of the free variables at each breakpoint.-   , modBreaks_decls :: !(Array BreakIndex [String])-        -- ^ An array giving the names of the declarations enclosing each breakpoint.-   , modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))-        -- ^ Array pointing to cost centre for each breakpoint-   , modBreaks_breakInfo :: IntMap CgBreakInfo-        -- ^ info about each breakpoint from the bytecode generator-   }--seqModBreaks :: ModBreaks -> ()-seqModBreaks ModBreaks{..} =-  rnf modBreaks_flags `seq`-  rnf modBreaks_locs `seq`-  rnf modBreaks_vars `seq`-  rnf modBreaks_decls `seq`-  rnf modBreaks_ccs `seq`-  rnf (fmap seqCgBreakInfo modBreaks_breakInfo)---- | Construct an empty ModBreaks-emptyModBreaks :: ModBreaks-emptyModBreaks = ModBreaks-   { modBreaks_flags = error "ModBreaks.modBreaks_array not initialised"-         -- ToDo: can we avoid this?-   , modBreaks_locs  = array (0,-1) []-   , modBreaks_vars  = array (0,-1) []-   , modBreaks_decls = array (0,-1) []-   , modBreaks_ccs = array (0,-1) []-   , modBreaks_breakInfo = IntMap.empty-   }

− compiler/ghci/LinkerTypes.hs

@@ -1,112 +0,0 @@------------------------------------------------------------------------------------ Types for the Dynamic Linker------ (c) The University of Glasgow 2019-----------------------------------------------------------------------------------module LinkerTypes (-      DynLinker(..),-      PersistentLinkerState(..),-      LinkerUnitId,-      Linkable(..),-      Unlinked(..),-      SptEntry(..)-    ) where--import GhcPrelude              ( FilePath, String, show )-import Data.Time               ( UTCTime )-import Data.Maybe              ( Maybe )-import Control.Concurrent.MVar ( MVar )-import Module                  ( InstalledUnitId, Module )-import ByteCodeTypes           ( ItblEnv, CompiledByteCode )-import Outputable-import Var                     ( Id )-import GHC.Fingerprint.Type    ( Fingerprint )-import NameEnv                 ( NameEnv )-import Name                    ( Name )-import GHCi.RemoteTypes        ( ForeignHValue )--type ClosureEnv = NameEnv (Name, ForeignHValue)--newtype DynLinker =-  DynLinker { dl_mpls :: MVar (Maybe PersistentLinkerState) }--data PersistentLinkerState-  = PersistentLinkerState {--       -- Current global mapping from Names to their true values-       closure_env :: ClosureEnv,--       -- The current global mapping from RdrNames of DataCons to-       -- info table addresses.-       -- When a new Unlinked is linked into the running image, or an existing-       -- module in the image is replaced, the itbl_env must be updated-       -- appropriately.-       itbl_env    :: !ItblEnv,--       -- The currently loaded interpreted modules (home package)-       bcos_loaded :: ![Linkable],--       -- And the currently-loaded compiled modules (home package)-       objs_loaded :: ![Linkable],--       -- The currently-loaded packages; always object code-       -- Held, as usual, in dependency order; though I am not sure if-       -- that is really important-       pkgs_loaded :: ![LinkerUnitId],--       -- we need to remember the name of previous temporary DLL/.so-       -- libraries so we can link them (see #10322)-       temp_sos :: ![(FilePath, String)] }---- TODO: Make this type more precise-type LinkerUnitId = InstalledUnitId---- | Information we can use to dynamically link modules into the compiler-data Linkable = LM {-  linkableTime     :: UTCTime,          -- ^ Time at which this linkable was built-                                        -- (i.e. when the bytecodes were produced,-                                        --       or the mod date on the files)-  linkableModule   :: Module,           -- ^ The linkable module itself-  linkableUnlinked :: [Unlinked]-    -- ^ Those files and chunks of code we have yet to link.-    ---    -- INVARIANT: A valid linkable always has at least one 'Unlinked' item.-    -- If this list is empty, the Linkable represents a fake linkable, which-    -- is generated in HscNothing mode to avoid recompiling modules.-    ---    -- ToDo: Do items get removed from this list when they get linked?- }--instance Outputable Linkable where-  ppr (LM when_made mod unlinkeds)-     = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)-       $$ nest 3 (ppr unlinkeds)---- | Objects which have yet to be linked by the compiler-data Unlinked-  = DotO FilePath      -- ^ An object file (.o)-  | DotA FilePath      -- ^ Static archive file (.a)-  | DotDLL FilePath    -- ^ Dynamically linked library file (.so, .dll, .dylib)-  | BCOs CompiledByteCode-         [SptEntry]    -- ^ A byte-code object, lives only in memory. Also-                       -- carries some static pointer table entries which-                       -- should be loaded along with the BCOs.-                       -- See Note [Grant plan for static forms] in-                       -- StaticPtrTable.--instance Outputable Unlinked where-  ppr (DotO path)   = text "DotO" <+> text path-  ppr (DotA path)   = text "DotA" <+> text path-  ppr (DotDLL path) = text "DotDLL" <+> text path-  ppr (BCOs bcos spt) = text "BCOs" <+> ppr bcos <+> ppr spt---- | An entry to be inserted into a module's static pointer table.--- See Note [Grand plan for static forms] in StaticPtrTable.-data SptEntry = SptEntry Id Fingerprint--instance Outputable SptEntry where-  ppr (SptEntry id fpr) = ppr id <> colon <+> ppr fpr-

− compiler/main/CmdLineParser.hs

@@ -1,339 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveFunctor #-}--------------------------------------------------------------------------------------- | Command-line parser------ This is an abstract command-line parser used by DynFlags.------ (c) The University of Glasgow 2005-------------------------------------------------------------------------------------module CmdLineParser-    (-      processArgs, OptKind(..), GhcFlagMode(..),-      CmdLineP(..), getCmdLineState, putCmdLineState,-      Flag(..), defFlag, defGhcFlag, defGhciFlag, defHiddenFlag,-      errorsToGhcException,--      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--import Control.Monad (liftM, ap)-------------------------------------------------------------         The Flag and OptKind types-----------------------------------------------------------data Flag m = Flag-    {   flagName    :: String,     -- Flag, without the leading "-"-        flagOptKind :: OptKind m,  -- What to do if we see it-        flagGhcMode :: GhcFlagMode    -- Which modes this flag affects-    }--defFlag :: String -> OptKind m -> Flag m-defFlag name optKind = Flag name optKind AllModes--defGhcFlag :: String -> OptKind m -> Flag m-defGhcFlag name optKind = Flag name optKind OnlyGhc--defGhciFlag :: String -> OptKind m -> Flag m-defGhciFlag name optKind = Flag name optKind OnlyGhci--defHiddenFlag :: String -> OptKind m -> Flag m-defHiddenFlag name optKind = Flag name optKind HiddenFlag---- | GHC flag modes describing when a flag has an effect.-data GhcFlagMode-    = OnlyGhc  -- ^ The flag only affects the non-interactive GHC-    | OnlyGhci -- ^ The flag only affects the interactive GHC-    | AllModes -- ^ The flag affects multiple ghc modes-    | HiddenFlag -- ^ This flag should not be seen in cli completion--data OptKind m                             -- Suppose the flag is -f-    = NoArg     (EwM m ())                 -- -f all by itself-    | HasArg    (String -> EwM m ())       -- -farg or -f arg-    | SepArg    (String -> EwM m ())       -- -f arg-    | Prefix    (String -> EwM m ())       -- -farg-    | OptPrefix (String -> EwM m ())       -- -f or -farg (i.e. the arg is optional)-    | OptIntSuffix (Maybe Int -> EwM m ()) -- -f or -f=n; pass n to fn-    | IntSuffix (Int -> EwM m ())          -- -f or -f=n; pass n to fn-    | FloatSuffix (Float -> EwM m ())      -- -f or -f=n; pass n to fn-    | PassFlag  (String -> EwM m ())       -- -f; pass "-f" fn-    | AnySuffix (String -> EwM m ())       -- -f or -farg; pass entire "-farg" to fn--------------------------------------------------------------         The EwM monad------------------------------------------------------------- | 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---- EwM ("errors and warnings monad") is a monad--- transformer for m that adds an (err, warn) state-newtype EwM m a = EwM { unEwM :: Located String -- Current parse arg-                              -> Errs -> Warns-                              -> m (Errs, Warns, a) }--instance Monad m => Functor (EwM m) where-    fmap = liftM--instance Monad m => Applicative (EwM m) where-    pure v = EwM (\_ e w -> return (e, w, v))-    (<*>) = ap--instance Monad m => Monad (EwM m) where-    (EwM f) >>= k = EwM (\l e w -> do (e', w', r) <- f l e w-                                      unEwM (k r) l e' w')--runEwM :: EwM m a -> m (Errs, Warns, a)-runEwM action = unEwM action (panic "processArgs: no arg yet") emptyBag emptyBag--setArg :: Located String -> EwM m () -> EwM m ()-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` Err (L loc e), ws, ()))--addWarn :: Monad m => String -> EwM m ()-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-    addFlagWarn ReasonDeprecatedFlag (arg ++ " is deprecated: " ++ s)--getArg :: Monad m => EwM m String-getArg = EwM (\(L _ arg) es ws -> return (es, ws, arg))--getCurLoc :: Monad m => EwM m SrcSpan-getCurLoc = EwM (\(L loc _) es ws -> return (es, ws, loc))--liftEwM :: Monad m => m a -> EwM m a-liftEwM action = EwM (\_ es ws -> do { r <- action; return (es, ws, r) })-------------------------------------------------------------- A state monad for use in the command-line parser------------------------------------------------------------- (CmdLineP s) typically instantiates the 'm' in (EwM m) and (OptKind m)-newtype CmdLineP s a = CmdLineP { runCmdLine :: s -> (a, s) }-    deriving (Functor)--instance Applicative (CmdLineP s) where-    pure a = CmdLineP $ \s -> (a, s)-    (<*>) = ap--instance Monad (CmdLineP s) where-    m >>= k = CmdLineP $ \s ->-                  let (a, s') = runCmdLine m s-                  in runCmdLine (k a) s'---getCmdLineState :: CmdLineP s s-getCmdLineState   = CmdLineP $ \s -> (s,s)-putCmdLineState :: s -> CmdLineP s ()-putCmdLineState s = CmdLineP $ \_ -> ((),s)--------------------------------------------------------------         Processing arguments-----------------------------------------------------------processArgs :: Monad m-            => [Flag m]               -- cmdline parser spec-            -> [Located String]       -- args-            -> m ( [Located String],  -- spare args-                   [Err],  -- errors-                   [Warn] ) -- warnings-processArgs spec args = do-    (errs, warns, spare) <- runEwM action-    return (spare, bagToList errs, bagToList warns)-  where-    action = process args []--    -- process :: [Located String] -> [Located String] -> EwM m [Located String]-    process [] spare = return (reverse spare)--    process (locArg@(L _ ('-' : arg)) : args) spare =-        case findArg spec arg of-            Just (rest, opt_kind) ->-                case processOneArg opt_kind rest arg args of-                    Left err ->-                        let b = process args spare-                        in (setArg locArg $ addErr err) >> b--                    Right (action,rest) ->-                        let b = process rest spare-                        in (setArg locArg $ action) >> b--            Nothing -> process args (locArg : spare)--    process (arg : args) spare = process args (arg : spare)---processOneArg :: OptKind m -> String -> String -> [Located String]-              -> Either String (EwM m (), [Located String])-processOneArg opt_kind rest arg args-  = let dash_arg = '-' : arg-        rest_no_eq = dropEq rest-    in case opt_kind of-        NoArg  a -> ASSERT(null rest) Right (a, args)--        HasArg f | notNull rest_no_eq -> Right (f rest_no_eq, args)-                 | otherwise -> case args of-                                    []               -> missingArgErr dash_arg-                                    (L _ arg1:args1) -> Right (f arg1, args1)--        -- See #9776-        SepArg f -> case args of-                        []               -> missingArgErr dash_arg-                        (L _ arg1:args1) -> Right (f arg1, args1)--        -- See #12625-        Prefix f | notNull rest_no_eq -> Right (f rest_no_eq, args)-                 | otherwise          -> missingArgErr  dash_arg--        PassFlag f  | notNull rest -> unknownFlagErr dash_arg-                    | otherwise    -> Right (f dash_arg, args)--        OptIntSuffix f | null rest                     -> Right (f Nothing,  args)-                       | Just n <- parseInt rest_no_eq -> Right (f (Just n), args)-                       | otherwise -> Left ("malformed integer argument in " ++ dash_arg)--        IntSuffix f | Just n <- parseInt rest_no_eq -> Right (f n, args)-                    | otherwise -> Left ("malformed integer argument in " ++ dash_arg)--        FloatSuffix f | Just n <- parseFloat rest_no_eq -> Right (f n, args)-                      | otherwise -> Left ("malformed float argument in " ++ dash_arg)--        OptPrefix f       -> Right (f rest_no_eq, args)-        AnySuffix f       -> Right (f dash_arg, args)--findArg :: [Flag m] -> String -> Maybe (String, OptKind m)-findArg spec arg =-    case sortBy (compare `on` (length . fst)) -- prefer longest matching flag-           [ (removeSpaces rest, optKind)-           | flag <- spec,-             let optKind  = flagOptKind flag,-             Just rest <- [stripPrefix (flagName flag) arg],-             arg_ok optKind rest arg ]-    of-        []      -> Nothing-        (one:_) -> Just one--arg_ok :: OptKind t -> [Char] -> String -> Bool-arg_ok (NoArg           _)  rest _   = null rest-arg_ok (HasArg          _)  _    _   = True-arg_ok (SepArg          _)  rest _   = null rest-arg_ok (Prefix          _)  _    _   = True -- Missing argument checked for in processOneArg t-                                            -- to improve error message (#12625)-arg_ok (OptIntSuffix    _)  _    _   = True-arg_ok (IntSuffix       _)  _    _   = True-arg_ok (FloatSuffix     _)  _    _   = True-arg_ok (OptPrefix       _)  _    _   = True-arg_ok (PassFlag        _)  rest _   = null rest-arg_ok (AnySuffix       _)  _    _   = True---- | Parse an Int------ Looks for "433" or "=342", with no trailing gubbins---   * n or =n      => Just n---   * gibberish    => Nothing-parseInt :: String -> Maybe Int-parseInt s = case reads s of-                 ((n,""):_) -> Just n-                 _          -> Nothing--parseFloat :: String -> Maybe Float-parseFloat s = case reads s of-                   ((n,""):_) -> Just n-                   _          -> Nothing---- | Discards a leading equals sign-dropEq :: String -> String-dropEq ('=' : s) = s-dropEq s         = s--unknownFlagErr :: String -> Either String a-unknownFlagErr f = Left ("unrecognised flag: " ++ f)--missingArgErr :: String -> Either String a-missingArgErr f = Left ("missing argument for flag: " ++ f)------------------------------------------------------------- Utils-------------------------------------------------------------- See Note [Handling errors when parsing flags]-errorsToGhcException :: [(String,    -- Location-                          String)]   -- Error-                     -> GhcException-errorsToGhcException errs =-    UsageError $ intercalate "\n" $ [ l ++ ": " ++ e | (l, e) <- errs ]--{- Note [Handling errors when parsing commandline flags]--Parsing of static and mode flags happens before any session is started, i.e.,-before the first call to 'GHC.withGhc'. Therefore, to report errors for-invalid usage of these two types of flags, we can not call any function that-needs DynFlags, as there are no DynFlags available yet (unsafeGlobalDynFlags-is not set either). So we always print "on the commandline" as the location,-which is true except for Api users, which is probably ok.--When reporting errors for invalid usage of dynamic flags we /can/ make use of-DynFlags, and we do so explicitly in DynFlags.parseDynamicFlagsFull.--Before, we called unsafeGlobalDynFlags when an invalid (combination of)-flag(s) was given on the commandline, resulting in panics (#9963).--}

− compiler/main/DriverPhases.hs

@@ -1,371 +0,0 @@-{-# LANGUAGE CPP #-}----------------------------------------------------------------------------------  $Id: DriverPhases.hs,v 1.38 2005/05/17 11:01:59 simonmar Exp $------ GHC Driver------ (c) The University of Glasgow 2002-----------------------------------------------------------------------------------module DriverPhases (-   HscSource(..), isHsBootOrSig, isHsigFile, hscSourceString,-   Phase(..),-   happensBefore, eqPhase, anyHsc, isStopLn,-   startPhase,-   phaseInputExt,--   isHaskellishSuffix,-   isHaskellSrcSuffix,-   isBackpackishSuffix,-   isObjectSuffix,-   isCishSuffix,-   isDynLibSuffix,-   isHaskellUserSrcSuffix,-   isHaskellSigSuffix,-   isSourceSuffix,--   isHaskellishTarget,--   isHaskellishFilename,-   isHaskellSrcFilename,-   isHaskellSigFilename,-   isObjectFilename,-   isCishFilename,-   isDynLibFilename,-   isHaskellUserSrcFilename,-   isSourceFilename- ) where--#include "HsVersions.h"--import GhcPrelude--import {-# SOURCE #-} DynFlags-import Outputable-import GHC.Platform-import System.FilePath-import Binary-import Util---------------------------------------------------------------------------------- Phases--{--   Phase of the           | Suffix saying | Flag saying   | (suffix of)-   compilation system     | ``start here''| ``stop after''| output file--   literate pre-processor | .lhs          | -             | --   C pre-processor (opt.) | -             | -E            | --   Haskell compiler       | .hs           | -C, -S        | .hc, .s-   C compiler (opt.)      | .hc or .c     | -S            | .s-   assembler              | .s  or .S     | -c            | .o-   linker                 | other         | -             | a.out--}---- Note [HscSource types]--- ~~~~~~~~~~~~~~~~~~~~~~--- There are three types of source file for Haskell code:------      * HsSrcFile is an ordinary hs file which contains code,------      * HsBootFile is an hs-boot file, which is used to break---        recursive module imports (there will always be an---        HsSrcFile associated with it), and------      * HsigFile is an hsig file, which contains only type---        signatures and is used to specify signatures for---        modules.------ Syntactically, hs-boot files and hsig files are quite similar: they--- only include type signatures and must be associated with an--- actual HsSrcFile.  isHsBootOrSig allows us to abstract over code--- which is indifferent to which.  However, there are some important--- differences, mostly owing to the fact that hsigs are proper--- modules (you `import Sig` directly) whereas HsBootFiles are--- temporary placeholders (you `import {-# SOURCE #-} Mod).--- When we finish compiling the true implementation of an hs-boot,--- we replace the HomeModInfo with the real HsSrcFile.  An HsigFile, on the--- other hand, is never replaced (in particular, we *cannot* use the--- HomeModInfo of the original HsSrcFile backing the signature, since it--- will export too many symbols.)------ Additionally, while HsSrcFile is the only Haskell file--- which has *code*, we do generate .o files for HsigFile, because--- this is how the recompilation checker figures out if a file--- needs to be recompiled.  These are fake object files which--- should NOT be linked against.--data HscSource-   = HsSrcFile | HsBootFile | HsigFile-     deriving( Eq, Ord, Show )-        -- Ord needed for the finite maps we build in CompManager--instance Binary HscSource where-    put_ bh HsSrcFile = putByte bh 0-    put_ bh HsBootFile = putByte bh 1-    put_ bh HsigFile = putByte bh 2-    get bh = do-        h <- getByte bh-        case h of-            0 -> return HsSrcFile-            1 -> return HsBootFile-            _ -> return HsigFile--hscSourceString :: HscSource -> String-hscSourceString HsSrcFile   = ""-hscSourceString HsBootFile  = "[boot]"-hscSourceString HsigFile    = "[sig]"---- See Note [isHsBootOrSig]-isHsBootOrSig :: HscSource -> Bool-isHsBootOrSig HsBootFile = True-isHsBootOrSig HsigFile   = True-isHsBootOrSig _          = False--isHsigFile :: HscSource -> Bool-isHsigFile HsigFile = True-isHsigFile _        = False--data Phase-        = Unlit HscSource-        | Cpp   HscSource-        | HsPp  HscSource-        | Hsc   HscSource-        | Ccxx          -- Compile C++-        | Cc            -- Compile C-        | Cobjc         -- Compile Objective-C-        | Cobjcxx       -- Compile Objective-C++-        | HCc           -- Haskellised C (as opposed to vanilla C) compilation-        | As Bool       -- Assembler for regular assembly files (Bool: with-cpp)-        | LlvmOpt       -- Run LLVM opt tool over llvm assembly-        | LlvmLlc       -- LLVM bitcode to native assembly-        | LlvmMangle    -- Fix up TNTC by processing assembly produced by LLVM-        | CmmCpp        -- pre-process Cmm source-        | Cmm           -- parse & compile Cmm code-        | MergeForeign  -- merge in the foreign object files--        -- The final phase is a pseudo-phase that tells the pipeline to stop.-        -- There is no runPhase case for it.-        | StopLn        -- Stop, but linking will follow, so generate .o file-  deriving (Eq, Show)--instance Outputable Phase where-    ppr p = text (show p)--anyHsc :: Phase-anyHsc = Hsc (panic "anyHsc")--isStopLn :: Phase -> Bool-isStopLn StopLn = True-isStopLn _      = False--eqPhase :: Phase -> Phase -> Bool--- Equality of constructors, ignoring the HscSource field--- NB: the HscSource field can be 'bot'; see anyHsc above-eqPhase (Unlit _)   (Unlit _)  = True-eqPhase (Cpp   _)   (Cpp   _)  = True-eqPhase (HsPp  _)   (HsPp  _)  = True-eqPhase (Hsc   _)   (Hsc   _)  = True-eqPhase Cc          Cc         = True-eqPhase Cobjc       Cobjc      = True-eqPhase HCc         HCc        = True-eqPhase (As x)      (As y)     = x == y-eqPhase LlvmOpt     LlvmOpt    = True-eqPhase LlvmLlc     LlvmLlc    = True-eqPhase LlvmMangle  LlvmMangle = True-eqPhase CmmCpp      CmmCpp     = True-eqPhase Cmm         Cmm        = True-eqPhase MergeForeign MergeForeign  = True-eqPhase StopLn      StopLn     = True-eqPhase Ccxx        Ccxx       = True-eqPhase Cobjcxx     Cobjcxx    = True-eqPhase _           _          = False--{- Note [Partial ordering on phases]--We want to know which phases will occur before which others. This is used for-sanity checking, to ensure that the pipeline will stop at some point (see-DriverPipeline.runPipeline).--A < B iff A occurs before B in a normal compilation pipeline.--There is explicitly not a total ordering on phases, because in registerised-builds, the phase `HsC` doesn't happen before nor after any other phase.--Although we check that a normal user doesn't set the stop_phase to HsC through-use of -C with registerised builds (in Main.checkOptions), it is still-possible for a ghc-api user to do so. So be careful when using the function-happensBefore, and don't think that `not (a <= b)` implies `b < a`.--}-happensBefore :: DynFlags -> Phase -> Phase -> Bool-happensBefore dflags p1 p2 = p1 `happensBefore'` p2-    where StopLn `happensBefore'` _ = False-          x      `happensBefore'` y = after_x `eqPhase` y-                                   || after_x `happensBefore'` y-              where after_x = nextPhase dflags x--nextPhase :: DynFlags -> Phase -> Phase-nextPhase dflags p-    -- A conservative approximation to the next phase, used in happensBefore-    = case p of-      Unlit sf   -> Cpp  sf-      Cpp   sf   -> HsPp sf-      HsPp  sf   -> Hsc  sf-      Hsc   _    -> maybeHCc-      LlvmOpt    -> LlvmLlc-      LlvmLlc    -> LlvmMangle-      LlvmMangle -> As False-      As _       -> MergeForeign-      Ccxx       -> As False-      Cc         -> As False-      Cobjc      -> As False-      Cobjcxx    -> As False-      CmmCpp     -> Cmm-      Cmm        -> maybeHCc-      HCc        -> As False-      MergeForeign -> StopLn-      StopLn     -> panic "nextPhase: nothing after StopLn"-    where maybeHCc = if platformUnregisterised (targetPlatform dflags)-                     then HCc-                     else As False---- the first compilation phase for a given file is determined--- by its suffix.-startPhase :: String -> Phase-startPhase "lhs"      = Unlit HsSrcFile-startPhase "lhs-boot" = Unlit HsBootFile-startPhase "lhsig"    = Unlit HsigFile-startPhase "hs"       = Cpp   HsSrcFile-startPhase "hs-boot"  = Cpp   HsBootFile-startPhase "hsig"     = Cpp   HsigFile-startPhase "hscpp"    = HsPp  HsSrcFile-startPhase "hspp"     = Hsc   HsSrcFile-startPhase "hc"       = HCc-startPhase "c"        = Cc-startPhase "cpp"      = Ccxx-startPhase "C"        = Cc-startPhase "m"        = Cobjc-startPhase "M"        = Cobjcxx-startPhase "mm"       = Cobjcxx-startPhase "cc"       = Ccxx-startPhase "cxx"      = Ccxx-startPhase "s"        = As False-startPhase "S"        = As True-startPhase "ll"       = LlvmOpt-startPhase "bc"       = LlvmLlc-startPhase "lm_s"     = LlvmMangle-startPhase "o"        = StopLn-startPhase "cmm"      = CmmCpp-startPhase "cmmcpp"   = Cmm-startPhase _          = StopLn     -- all unknown file types---- This is used to determine the extension for the output from the--- current phase (if it generates a new file).  The extension depends--- on the next phase in the pipeline.-phaseInputExt :: Phase -> String-phaseInputExt (Unlit HsSrcFile)   = "lhs"-phaseInputExt (Unlit HsBootFile)  = "lhs-boot"-phaseInputExt (Unlit HsigFile)    = "lhsig"-phaseInputExt (Cpp   _)           = "lpp"       -- intermediate only-phaseInputExt (HsPp  _)           = "hscpp"     -- intermediate only-phaseInputExt (Hsc   _)           = "hspp"      -- intermediate only-        -- NB: as things stand, phaseInputExt (Hsc x) must not evaluate x-        --     because runPipeline uses the StopBefore phase to pick the-        --     output filename.  That could be fixed, but watch out.-phaseInputExt HCc                 = "hc"-phaseInputExt Ccxx                = "cpp"-phaseInputExt Cobjc               = "m"-phaseInputExt Cobjcxx             = "mm"-phaseInputExt Cc                  = "c"-phaseInputExt (As True)           = "S"-phaseInputExt (As False)          = "s"-phaseInputExt LlvmOpt             = "ll"-phaseInputExt LlvmLlc             = "bc"-phaseInputExt LlvmMangle          = "lm_s"-phaseInputExt CmmCpp              = "cmmcpp"-phaseInputExt Cmm                 = "cmm"-phaseInputExt MergeForeign        = "o"-phaseInputExt StopLn              = "o"--haskellish_src_suffixes, backpackish_suffixes, haskellish_suffixes, cish_suffixes,-    haskellish_user_src_suffixes, haskellish_sig_suffixes- :: [String]--- When a file with an extension in the haskellish_src_suffixes group is--- loaded in --make mode, its imports will be loaded too.-haskellish_src_suffixes      = haskellish_user_src_suffixes ++-                               [ "hspp", "hscpp" ]-haskellish_suffixes          = haskellish_src_suffixes ++-                               [ "hc", "cmm", "cmmcpp" ]-cish_suffixes                = [ "c", "cpp", "C", "cc", "cxx", "s", "S", "ll", "bc", "lm_s", "m", "M", "mm" ]---- Will not be deleted as temp files:-haskellish_user_src_suffixes =-  haskellish_sig_suffixes ++ [ "hs", "lhs", "hs-boot", "lhs-boot" ]-haskellish_sig_suffixes      = [ "hsig", "lhsig" ]-backpackish_suffixes         = [ "bkp" ]--objish_suffixes :: Platform -> [String]--- Use the appropriate suffix for the system on which--- the GHC-compiled code will run-objish_suffixes platform = case platformOS platform of-  OSMinGW32 -> [ "o", "O", "obj", "OBJ" ]-  _         -> [ "o" ]--dynlib_suffixes :: Platform -> [String]-dynlib_suffixes platform = case platformOS platform of-  OSMinGW32 -> ["dll", "DLL"]-  OSDarwin  -> ["dylib", "so"]-  _         -> ["so"]--isHaskellishSuffix, isBackpackishSuffix, isHaskellSrcSuffix, isCishSuffix,-    isHaskellUserSrcSuffix, isHaskellSigSuffix- :: String -> Bool-isHaskellishSuffix     s = s `elem` haskellish_suffixes-isBackpackishSuffix    s = s `elem` backpackish_suffixes-isHaskellSigSuffix     s = s `elem` haskellish_sig_suffixes-isHaskellSrcSuffix     s = s `elem` haskellish_src_suffixes-isCishSuffix           s = s `elem` cish_suffixes-isHaskellUserSrcSuffix s = s `elem` haskellish_user_src_suffixes--isObjectSuffix, isDynLibSuffix :: Platform -> String -> Bool-isObjectSuffix platform s = s `elem` objish_suffixes platform-isDynLibSuffix platform s = s `elem` dynlib_suffixes platform--isSourceSuffix :: String -> Bool-isSourceSuffix suff  = isHaskellishSuffix suff-                    || isCishSuffix suff-                    || isBackpackishSuffix suff---- | When we are given files (modified by -x arguments) we need--- to determine if they are Haskellish or not to figure out--- how we should try to compile it.  The rules are:------      1. If no -x flag was specified, we check to see if---         the file looks like a module name, has no extension,---         or has a Haskell source extension.------      2. If an -x flag was specified, we just make sure the---         specified suffix is a Haskell one.-isHaskellishTarget :: (String, Maybe Phase) -> Bool-isHaskellishTarget (f,Nothing) =-  looksLikeModuleName f || isHaskellSrcFilename f || not (hasExtension f)-isHaskellishTarget (_,Just phase) =-  phase `notElem` [ As True, As False, Cc, Cobjc, Cobjcxx, CmmCpp, Cmm-                  , StopLn]--isHaskellishFilename, isHaskellSrcFilename, isCishFilename,-    isHaskellUserSrcFilename, isSourceFilename, isHaskellSigFilename- :: FilePath -> Bool--- takeExtension return .foo, so we drop 1 to get rid of the .-isHaskellishFilename     f = isHaskellishSuffix     (drop 1 $ takeExtension f)-isHaskellSrcFilename     f = isHaskellSrcSuffix     (drop 1 $ takeExtension f)-isCishFilename           f = isCishSuffix           (drop 1 $ takeExtension f)-isHaskellUserSrcFilename f = isHaskellUserSrcSuffix (drop 1 $ takeExtension f)-isSourceFilename         f = isSourceSuffix         (drop 1 $ takeExtension f)-isHaskellSigFilename     f = isHaskellSigSuffix     (drop 1 $ takeExtension f)--isObjectFilename, isDynLibFilename :: Platform -> FilePath -> Bool-isObjectFilename platform f = isObjectSuffix platform (drop 1 $ takeExtension f)-isDynLibFilename platform f = isDynLibSuffix platform (drop 1 $ takeExtension f)

− compiler/main/DynFlags.hs

@@ -1,5920 +0,0 @@-{-# OPTIONS_GHC -O0 #-}-{-# LANGUAGE CPP #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE RankNTypes #-}--------------------------------------------------------------------------------------- | Dynamic flags------ Most flags are dynamic flags, which means they can change from compilation--- to compilation using @OPTIONS_GHC@ pragmas, and in a multi-session GHC each--- session can be using different dynamic flags. Dynamic flags can also be set--- at the prompt in GHCi.------ (c) The University of Glasgow 2005-------------------------------------------------------------------------------------{-# OPTIONS_GHC -fno-cse #-}--- -fno-cse is needed for GLOBAL_VAR's to behave properly-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}--module DynFlags (-        -- * Dynamic flags and associated configuration types-        DumpFlag(..),-        GeneralFlag(..),-        WarningFlag(..), WarnReason(..),-        Language(..),-        PlatformConstants(..),-        FatalMessager, LogAction, FlushOut(..), FlushErr(..),-        ProfAuto(..),-        glasgowExtsFlags,-        warningGroups, warningHierarchies,-        hasPprDebug, hasNoDebugOutput, hasNoStateHack, hasNoOptCoercion,-        dopt, dopt_set, dopt_unset,-        gopt, gopt_set, gopt_unset, setGeneralFlag', unSetGeneralFlag',-        wopt, wopt_set, wopt_unset,-        wopt_fatal, wopt_set_fatal, wopt_unset_fatal,-        xopt, xopt_set, xopt_unset,-        xopt_set_unlessExplSpec,-        lang_set,-        useUnicodeSyntax,-        useStarIsType,-        whenGeneratingDynamicToo, ifGeneratingDynamicToo,-        whenCannotGenerateDynamicToo,-        dynamicTooMkDynamicDynFlags,-        dynamicOutputFile,-        DynFlags(..),-        FlagSpec(..),-        HasDynFlags(..), ContainsDynFlags(..),-        RtsOptsEnabled(..),-        HscTarget(..), isObjectTarget, defaultObjectTarget,-        targetRetainsAllBindings,-        GhcMode(..), isOneShot,-        GhcLink(..), isNoLink,-        PackageFlag(..), PackageArg(..), ModRenaming(..),-        packageFlagsChanged,-        IgnorePackageFlag(..), TrustFlag(..),-        PackageDBFlag(..), PkgDbRef(..),-        Option(..), showOpt,-        DynLibLoader(..),-        fFlags, fLangFlags, xFlags,-        wWarningFlags,-        dynFlagDependencies,-        makeDynFlagsConsistent,-        shouldUseColor,-        shouldUseHexWordLiterals,-        positionIndependent,-        optimisationFlags,-        setFlagsFromEnvFile,--        Way(..), mkBuildTag, wayRTSOnly, addWay', updateWays,-        wayGeneralFlags, wayUnsetGeneralFlags,--        thisPackage, thisComponentId, thisUnitIdInsts,--        -- ** Log output-        putLogMsg,--        -- ** Safe Haskell-        SafeHaskellMode(..),-        safeHaskellOn, safeHaskellModeEnabled,-        safeImportsOn, safeLanguageOn, safeInferOn,-        packageTrustOn,-        safeDirectImpsReq, safeImplicitImpsReq,-        unsafeFlags, unsafeFlagsForInfer,--        -- ** LLVM Targets-        LlvmTarget(..), LlvmConfig(..),--        -- ** System tool settings and locations-        Settings(..),-        sProgramName,-        sProjectVersion,-        sGhcUsagePath,-        sGhciUsagePath,-        sToolDir,-        sTopDir,-        sTmpDir,-        sGlobalPackageDatabasePath,-        sLdSupportsCompactUnwind,-        sLdSupportsBuildId,-        sLdSupportsFilelist,-        sLdIsGnuLd,-        sGccSupportsNoPie,-        sPgm_L,-        sPgm_P,-        sPgm_F,-        sPgm_c,-        sPgm_a,-        sPgm_l,-        sPgm_dll,-        sPgm_T,-        sPgm_windres,-        sPgm_libtool,-        sPgm_ar,-        sPgm_ranlib,-        sPgm_lo,-        sPgm_lc,-        sPgm_lcc,-        sPgm_i,-        sOpt_L,-        sOpt_P,-        sOpt_P_fingerprint,-        sOpt_F,-        sOpt_c,-        sOpt_cxx,-        sOpt_a,-        sOpt_l,-        sOpt_windres,-        sOpt_lo,-        sOpt_lc,-        sOpt_lcc,-        sOpt_i,-        sExtraGccViaCFlags,-        sTargetPlatformString,-        sIntegerLibrary,-        sIntegerLibraryType,-        sGhcWithInterpreter,-        sGhcWithNativeCodeGen,-        sGhcWithSMP,-        sGhcRTSWays,-        sTablesNextToCode,-        sLeadingUnderscore,-        sLibFFI,-        sGhcThreaded,-        sGhcDebugged,-        sGhcRtsWithLibdw,-        IntegerLibrary(..),-        GhcNameVersion(..),-        FileSettings(..),-        PlatformMisc(..),-        settings,-        programName, projectVersion,-        ghcUsagePath, ghciUsagePath, topDir, tmpDir,-        versionedAppDir, versionedFilePath,-        extraGccViaCFlags, globalPackageDatabasePath,-        pgm_L, pgm_P, pgm_F, pgm_c, pgm_a, pgm_l, pgm_dll, pgm_T,-        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_cxx, opt_a, opt_l, opt_i,-        opt_P_signature,-        opt_windres, opt_lo, opt_lc, opt_lcc,-        tablesNextToCode,--        -- ** Manipulating DynFlags-        addPluginModuleName,-        defaultDynFlags,                -- Settings -> DynFlags-        defaultWays,-        interpWays,-        interpreterProfiled, interpreterDynamic,-        initDynFlags,                   -- DynFlags -> IO DynFlags-        defaultFatalMessager,-        defaultLogAction,-        defaultLogActionHPrintDoc,-        defaultLogActionHPutStrDoc,-        defaultFlushOut,-        defaultFlushErr,--        getOpts,                        -- DynFlags -> (DynFlags -> [a]) -> [a]-        getVerbFlags,-        updOptLevel,-        setTmpDir,-        setUnitId,-        canonicalizeHomeModule,-        canonicalizeModuleIfHome,--        -- ** Parsing DynFlags-        parseDynamicFlagsCmdLine,-        parseDynamicFilePragma,-        parseDynamicFlagsFull,--        -- ** Available DynFlags-        allNonDeprecatedFlags,-        flagsAll,-        flagsDynamic,-        flagsPackage,-        flagsForCompletion,--        supportedLanguagesAndExtensions,-        languageExtensions,--        -- ** DynFlags C compiler options-        picCCOpts, picPOpts,--        -- * Compiler configuration suitable for display to the user-        compilerInfo,--        rtsIsProfiled,-        dynamicGhc,--#include "GHCConstantsHaskellExports.hs"-        bLOCK_SIZE_W,-        wORD_SIZE_IN_BITS,-        wordAlignment,-        tAG_MASK,-        mAX_PTR_TAG,-        tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD,--        unsafeGlobalDynFlags, setUnsafeGlobalDynFlags,--        -- * SSE and AVX-        isSseEnabled,-        isSse2Enabled,-        isSse4_2Enabled,-        isBmiEnabled,-        isBmi2Enabled,-        isAvxEnabled,-        isAvx2Enabled,-        isAvx512cdEnabled,-        isAvx512erEnabled,-        isAvx512fEnabled,-        isAvx512pfEnabled,--        -- * Linker/compiler information-        LinkerInfo(..),-        CompilerInfo(..),--        -- * File cleanup-        FilesToClean(..), emptyFilesToClean,--        -- * Include specifications-        IncludeSpecs(..), addGlobalInclude, addQuoteInclude, flattenIncludes,---        -- * Make use of the Cmm CFG-        CfgWeights(..), backendMaintainsCfg-  ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.Platform-import GHC.UniqueSubdir (uniqueSubdir)-import PlatformConstants-import Module-import {-# SOURCE #-} Plugins-import {-# SOURCE #-} Hooks-import {-# SOURCE #-} PrelNames ( mAIN )-import {-# SOURCE #-} Packages (PackageState, emptyPackageState, PackageDatabase)-import DriverPhases     ( Phase(..), phaseInputExt )-import Config-import CliOption-import CmdLineParser hiding (WarnReason(..))-import qualified CmdLineParser as Cmd-import Constants-import GhcNameVersion-import Panic-import qualified PprColour as Col-import Util-import Maybes-import MonadUtils-import qualified Pretty-import SrcLoc-import BasicTypes       ( Alignment, alignmentOf, IntWithInf, treatZeroAsInf )-import FastString-import Fingerprint-import FileSettings-import Outputable-import Settings-import ToolSettings--import Foreign.C        ( CInt(..) )-import System.IO.Unsafe ( unsafeDupablePerformIO )-import {-# SOURCE #-} ErrUtils ( Severity(..), MsgDoc, mkLocMessageAnn-                               , getCaretDiagnostic, DumpAction, TraceAction-                               , defaultDumpAction, defaultTraceAction )-import Json-import SysTools.Terminal ( stderrSupportsAnsiColors )-import SysTools.BaseDir ( expandToolDir, expandTopDir )--import System.IO.Unsafe ( unsafePerformIO )-import Data.IORef-import Control.Arrow ((&&&))-import Control.Monad-import Control.Monad.Trans.Class-import Control.Monad.Trans.Writer-import Control.Monad.Trans.Reader-import Control.Monad.Trans.Except--import Data.Ord-import Data.Bits-import Data.Char-import Data.Int-import Data.List-import Data.Map (Map)-import qualified Data.Map as Map-import Data.Set (Set)-import qualified Data.Set as Set-import Data.Word-import System.FilePath-import System.Directory-import System.Environment (lookupEnv)-import System.IO-import System.IO.Error-import Text.ParserCombinators.ReadP hiding (char)-import Text.ParserCombinators.ReadP as R--import EnumSet (EnumSet)-import qualified EnumSet--import GHC.Foreign (withCString, peekCString)-import qualified GHC.LanguageExtensions as LangExt--#if GHC_STAGE >= 2--- used by SHARED_GLOBAL_VAR-import Foreign (Ptr)-#endif---- Note [Updating flag description in the User's Guide]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ If you modify anything in this file please make sure that your changes are--- 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]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ The command line interface completion (in for example bash) is an easy way--- for the developer to learn what flags are available from GHC.--- GHC helps by separating which flags are available when compiling with GHC,--- and which flags are available when using GHCi.--- A flag is assumed to either work in both these modes, or only in one of them.--- When adding or changing a flag, please consider for which mode the flag will--- have effect, and annotate it accordingly. For Flags use defFlag, defGhcFlag,--- defGhciFlag, and for FlagSpec use flagSpec or flagGhciSpec.---- Note [Adding a language extension]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ There are a few steps to adding (or removing) a language extension,------  * Adding the extension to GHC.LanguageExtensions------    The Extension type in libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs---    is the canonical list of language extensions known by GHC.------  * Adding a flag to DynFlags.xFlags------    This is fairly self-explanatory. The name should be concise, memorable,---    and consistent with any previous implementations of the similar idea in---    other Haskell compilers.------  * Adding the flag to the documentation------    This is the same as any other flag. See---    Note [Updating flag description in the User's Guide]------  * Adding the flag to Cabal------    The Cabal library has its own list of all language extensions supported---    by all major compilers. This is the list that user code being uploaded---    to Hackage is checked against to ensure language extension validity.---    Consequently, it is very important that this list remains up-to-date.------    To this end, there is a testsuite test (testsuite/tests/driver/T4437.hs)---    whose job it is to ensure these GHC's extensions are consistent with---    Cabal.------    The recommended workflow is,------     1. Temporarily add your new language extension to the---        expectedGhcOnlyExtensions list in T4437 to ensure the test doesn't---        break while Cabal is updated.------     2. After your GHC change is accepted, submit a Cabal pull request adding---        your new extension to Cabal's list (found in---        Cabal/Language/Haskell/Extension.hs).------     3. After your Cabal change is accepted, let the GHC developers know so---        they can update the Cabal submodule and remove the extensions from---        expectedGhcOnlyExtensions.------  * Adding the flag to the GHC Wiki------    There is a change log tracking language extension additions and removals---    on the GHC wiki:  https://gitlab.haskell.org/ghc/ghc/wikis/language-pragma-history------  See #4437 and #8176.---- -------------------------------------------------------------------------------- DynFlags--data DumpFlag--- See Note [Updating flag description in the User's Guide]--   -- debugging flags-   = Opt_D_dump_cmm-   | Opt_D_dump_cmm_from_stg-   | Opt_D_dump_cmm_raw-   | Opt_D_dump_cmm_verbose_by_proc-   -- All of the cmm subflags (there are a lot!) automatically-   -- enabled if you run -ddump-cmm-verbose-by-proc-   -- Each flag corresponds to exact stage of Cmm pipeline.-   | Opt_D_dump_cmm_verbose-   -- same as -ddump-cmm-verbose-by-proc but writes each stage-   -- to a separate file (if used with -ddump-to-file)-   | Opt_D_dump_cmm_cfg-   | Opt_D_dump_cmm_cbe-   | Opt_D_dump_cmm_switch-   | Opt_D_dump_cmm_proc-   | Opt_D_dump_cmm_sp-   | Opt_D_dump_cmm_sink-   | Opt_D_dump_cmm_caf-   | Opt_D_dump_cmm_procmap-   | Opt_D_dump_cmm_split-   | Opt_D_dump_cmm_info-   | Opt_D_dump_cmm_cps-   -- end cmm subflags-   | Opt_D_dump_cfg_weights -- ^ Dump the cfg used for block layout.-   | Opt_D_dump_asm-   | Opt_D_dump_asm_native-   | Opt_D_dump_asm_liveness-   | Opt_D_dump_asm_regalloc-   | Opt_D_dump_asm_regalloc_stages-   | Opt_D_dump_asm_conflicts-   | Opt_D_dump_asm_stats-   | Opt_D_dump_asm_expanded-   | Opt_D_dump_llvm-   | Opt_D_dump_core_stats-   | Opt_D_dump_deriv-   | Opt_D_dump_ds-   | Opt_D_dump_ds_preopt-   | Opt_D_dump_foreign-   | Opt_D_dump_inlinings-   | Opt_D_dump_rule_firings-   | Opt_D_dump_rule_rewrites-   | Opt_D_dump_simpl_trace-   | Opt_D_dump_occur_anal-   | Opt_D_dump_parsed-   | Opt_D_dump_parsed_ast-   | Opt_D_dump_rn-   | Opt_D_dump_rn_ast-   | Opt_D_dump_simpl-   | Opt_D_dump_simpl_iterations-   | Opt_D_dump_spec-   | Opt_D_dump_prep-   | Opt_D_dump_stg -- CoreToStg output-   | Opt_D_dump_stg_unarised -- STG after unarise-   | Opt_D_dump_stg_final -- STG after stg2stg-   | Opt_D_dump_call_arity-   | Opt_D_dump_exitify-   | Opt_D_dump_stranal-   | Opt_D_dump_str_signatures-   | Opt_D_dump_tc-   | Opt_D_dump_tc_ast-   | Opt_D_dump_types-   | Opt_D_dump_rules-   | Opt_D_dump_cse-   | Opt_D_dump_worker_wrapper-   | Opt_D_dump_rn_trace-   | Opt_D_dump_rn_stats-   | Opt_D_dump_opt_cmm-   | Opt_D_dump_simpl_stats-   | Opt_D_dump_cs_trace -- Constraint solver in type checker-   | Opt_D_dump_tc_trace-   | Opt_D_dump_ec_trace -- Pattern match exhaustiveness checker-   | Opt_D_dump_if_trace-   | Opt_D_dump_vt_trace-   | Opt_D_dump_splices-   | Opt_D_th_dec_file-   | Opt_D_dump_BCOs-   | Opt_D_dump_ticked-   | Opt_D_dump_rtti-   | Opt_D_source_stats-   | Opt_D_verbose_stg2stg-   | Opt_D_dump_hi-   | 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-   | Opt_D_dump_json-   | Opt_D_ppr_debug-   | 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]--   = Opt_DumpToFile                     -- ^ Append dump output to files instead of stdout.-   | Opt_D_faststring_stats-   | Opt_D_dump_minimal_imports-   | Opt_DoCoreLinting-   | Opt_DoStgLinting-   | Opt_DoCmmLinting-   | Opt_DoAsmLinting-   | Opt_DoAnnotationLinting-   | Opt_NoLlvmMangler                  -- hidden flag-   | Opt_FastLlvm                       -- hidden flag-   | Opt_NoTypeableBinds--   | Opt_WarnIsError                    -- -Werror; makes warnings fatal-   | Opt_ShowWarnGroups                 -- Show the group a warning belongs to-   | Opt_HideSourcePaths                -- Hide module source/object paths--   | Opt_PrintExplicitForalls-   | Opt_PrintExplicitKinds-   | Opt_PrintExplicitCoercions-   | Opt_PrintExplicitRuntimeReps-   | Opt_PrintEqualityRelations-   | Opt_PrintAxiomIncomps-   | Opt_PrintUnicodeSyntax-   | Opt_PrintExpandedSynonyms-   | Opt_PrintPotentialInstances-   | Opt_PrintTypecheckerElaboration--   -- optimisation opts-   | Opt_CallArity-   | Opt_Exitification-   | Opt_Strictness-   | Opt_LateDmdAnal                    -- #6087-   | Opt_KillAbsence-   | Opt_KillOneShot-   | Opt_FullLaziness-   | Opt_FloatIn-   | Opt_LateSpecialise-   | Opt_Specialise-   | Opt_SpecialiseAggressively-   | Opt_CrossModuleSpecialise-   | Opt_StaticArgumentTransformation-   | Opt_CSE-   | Opt_StgCSE-   | Opt_StgLiftLams-   | Opt_LiberateCase-   | Opt_SpecConstr-   | Opt_SpecConstrKeen-   | Opt_DoLambdaEtaExpansion-   | Opt_IgnoreAsserts-   | Opt_DoEtaReduction-   | Opt_CaseMerge-   | Opt_CaseFolding                    -- Constant folding through case-expressions-   | Opt_UnboxStrictFields-   | Opt_UnboxSmallStrictFields-   | Opt_DictsCheap-   | Opt_EnableRewriteRules             -- Apply rewrite rules during simplification-   | Opt_EnableThSpliceWarnings         -- Enable warnings for TH splices-   | Opt_RegsGraph                      -- do graph coloring register allocation-   | Opt_RegsIterative                  -- do iterative coalescing graph coloring register allocation-   | Opt_PedanticBottoms                -- Be picky about how we treat bottom-   | Opt_LlvmTBAA                       -- Use LLVM TBAA infrastructure for improving AA (hidden flag)-   | Opt_LlvmFillUndefWithGarbage       -- Testing for undef bugs (hidden flag)-   | Opt_IrrefutableTuples-   | Opt_CmmSink-   | Opt_CmmElimCommonBlocks-   | Opt_AsmShortcutting-   | Opt_OmitYields-   | Opt_FunToThunk               -- allow WwLib.mkWorkerArgs to remove all value lambdas-   | Opt_DictsStrict                     -- be strict in argument dictionaries-   | Opt_DmdTxDictSel              -- use a special demand transformer for dictionary selectors-   | Opt_Loopification                  -- See Note [Self-recursive tail calls]-   | Opt_CfgBlocklayout             -- ^ Use the cfg based block layout algorithm.-   | Opt_WeightlessBlocklayout         -- ^ Layout based on last instruction per block.-   | Opt_CprAnal-   | Opt_WorkerWrapper-   | Opt_SolveConstantDicts-   | Opt_AlignmentSanitisation-   | Opt_CatchBottoms-   | Opt_NumConstantFolding--   -- 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-   | Opt_ExposeAllUnfoldings-   | Opt_WriteInterface -- forces .hi files to be written even with -fno-code-   | Opt_WriteHie -- generate .hie files--   -- profiling opts-   | Opt_AutoSccsOnIndividualCafs-   | Opt_ProfCountEntries--   -- misc opts-   | Opt_Pp-   | Opt_ForceRecomp-   | Opt_IgnoreOptimChanges-   | Opt_IgnoreHpcChanges-   | Opt_ExcessPrecision-   | Opt_EagerBlackHoling-   | Opt_NoHsMain-   | Opt_SplitSections-   | Opt_StgStats-   | Opt_HideAllPackages-   | Opt_HideAllPluginPackages-   | Opt_PrintBindResult-   | Opt_Haddock-   | Opt_HaddockOptions-   | Opt_BreakOnException-   | Opt_BreakOnError-   | Opt_PrintEvldWithShow-   | Opt_PrintBindContents-   | Opt_GenManifest-   | Opt_EmbedManifest-   | Opt_SharedImplib-   | Opt_BuildingCabalPackage-   | Opt_IgnoreDotGhci-   | Opt_GhciSandbox-   | Opt_GhciHistory-   | Opt_GhciLeakCheck-   | Opt_ValidateHie-   | Opt_LocalGhciHistory-   | Opt_NoIt-   | Opt_HelpfulErrors-   | Opt_DeferTypeErrors-   | Opt_DeferTypedHoles-   | Opt_DeferOutOfScopeVariables-   | Opt_PIC                         -- ^ @-fPIC@-   | Opt_PIE                         -- ^ @-fPIE@-   | Opt_PICExecutable               -- ^ @-pie@-   | Opt_ExternalDynamicRefs-   | Opt_SccProfilingOn-   | Opt_Ticky-   | Opt_Ticky_Allocd-   | Opt_Ticky_LNE-   | Opt_Ticky_Dyn_Thunk-   | Opt_RPath-   | Opt_RelativeDynlibPaths-   | Opt_Hpc-   | Opt_FlatCache-   | Opt_ExternalInterpreter-   | Opt_OptimalApplicativeDo-   | Opt_VersionMacros-   | Opt_WholeArchiveHsLibs-   -- copy all libs into a single folder prior to linking binaries-   -- this should elivate the excessive command line limit restrictions-   -- on windows, by only requiring a single -L argument instead of-   -- one for each dependency.  At the time of this writing, gcc-   -- forwards all -L flags to the collect2 command without using a-   -- response file and as such breaking apart.-   | Opt_SingleLibFolder-   | Opt_KeepCAFs-   | Opt_KeepGoing-   | Opt_ByteCode--   -- output style opts-   | Opt_ErrorSpans -- Include full span info in error messages,-                    -- instead of just the start position.-   | Opt_DeferDiagnostics-   | Opt_DiagnosticsShowCaret -- Show snippets of offending code-   | Opt_PprCaseAsLet-   | Opt_PprShowTicks-   | Opt_ShowHoleConstraints-    -- Options relating to the display of valid hole fits-    -- when generating an error message for a typed hole-    -- See Note [Valid hole fits include] in TcHoleErrors.hs-   | Opt_ShowValidHoleFits-   | Opt_SortValidHoleFits-   | Opt_SortBySizeHoleFits-   | Opt_SortBySubsumHoleFits-   | Opt_AbstractRefHoleFits-   | Opt_UnclutterValidHoleFits-   | Opt_ShowTypeAppOfHoleFits-   | Opt_ShowTypeAppVarsOfHoleFits-   | Opt_ShowDocsOfHoleFits-   | Opt_ShowTypeOfHoleFits-   | Opt_ShowProvOfHoleFits-   | Opt_ShowMatchesOfHoleFits--   | Opt_ShowLoadedModules-   | Opt_HexWordLiterals -- See Note [Print Hexadecimal Literals]--   -- Suppress all coercions, them replacing with '...'-   | Opt_SuppressCoercions-   | Opt_SuppressVarKinds-   -- Suppress module id prefixes on variables.-   | Opt_SuppressModulePrefixes-   -- Suppress type applications.-   | Opt_SuppressTypeApplications-   -- Suppress info such as arity and unfoldings on identifiers.-   | Opt_SuppressIdInfo-   -- Suppress separate type signatures in core, but leave types on-   -- lambda bound vars-   | Opt_SuppressUnfoldings-   -- Suppress the details of even stable unfoldings-   | Opt_SuppressTypeSignatures-   -- Suppress unique ids on variables.-   -- Except for uniques, as some simplifier phases introduce new-   -- variables that have otherwise identical names.-   | Opt_SuppressUniques-   | Opt_SuppressStgExts-   | Opt_SuppressTicks     -- Replaces Opt_PprShowTicks-   | Opt_SuppressTimestamps -- ^ Suppress timestamps in dumps--   -- temporary flags-   | Opt_AutoLinkPackages-   | Opt_ImplicitImportQualified--   -- keeping stuff-   | Opt_KeepHscppFiles-   | Opt_KeepHiDiffs-   | Opt_KeepHcFiles-   | Opt_KeepSFiles-   | Opt_KeepTmpFiles-   | Opt_KeepRawTokenStream-   | Opt_KeepLlvmFiles-   | Opt_KeepHiFiles-   | Opt_KeepOFiles--   | Opt_BuildDynamicToo--   -- safe haskell flags-   | Opt_DistrustAllPackages-   | Opt_PackageTrust-   | Opt_PluginTrustworthy--   | Opt_G_NoStateHack-   | 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_LateSpecialise-   , Opt_Specialise-   , Opt_SpecialiseAggressively-   , Opt_CrossModuleSpecialise-   , Opt_StaticArgumentTransformation-   , Opt_CSE-   , Opt_StgCSE-   , Opt_StgLiftLams-   , 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_RegsGraph-   , Opt_RegsIterative-   , Opt_PedanticBottoms-   , Opt_LlvmTBAA-   , Opt_LlvmFillUndefWithGarbage-   , Opt_IrrefutableTuples-   , Opt_CmmSink-   , Opt_CmmElimCommonBlocks-   , Opt_AsmShortcutting-   , Opt_OmitYields-   , Opt_FunToThunk-   , Opt_DictsStrict-   , Opt_DmdTxDictSel-   , Opt_Loopification-   , Opt_CfgBlocklayout-   , Opt_WeightlessBlocklayout-   , 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-  -- | Warning was enabled with the flag-  | Reason !WarningFlag-  -- | Warning was made an error because of -Werror or -Werror=WarningFlag-  | ErrReason !(Maybe WarningFlag)-  deriving Show---- | Used to differentiate the scope an include needs to apply to.--- We have to split the include paths to avoid accidentally forcing recursive--- includes since -I overrides the system search paths. See #14312.-data IncludeSpecs-  = IncludeSpecs { includePathsQuote  :: [String]-                 , includePathsGlobal :: [String]-                 }-  deriving Show---- | Append to the list of includes a path that shall be included using `-I`--- when the C compiler is called. These paths override system search paths.-addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs-addGlobalInclude spec paths  = let f = includePathsGlobal spec-                               in spec { includePathsGlobal = f ++ paths }---- | Append to the list of includes a path that shall be included using--- `-iquote` when the C compiler is called. These paths only apply when quoted--- includes are used. e.g. #include "foo.h"-addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs-addQuoteInclude spec paths  = let f = includePathsQuote spec-                              in spec { includePathsQuote = f ++ paths }---- | Concatenate and flatten the list of global and quoted includes returning--- just a flat list of paths.-flattenIncludes :: IncludeSpecs -> [String]-flattenIncludes specs = includePathsQuote specs ++ includePathsGlobal specs--instance Outputable WarnReason where-  ppr = text . show--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]-     Opt_WarnDuplicateExports-   | Opt_WarnDuplicateConstraints-   | Opt_WarnRedundantConstraints-   | Opt_WarnHiShadows-   | Opt_WarnImplicitPrelude-   | Opt_WarnIncompletePatterns-   | Opt_WarnIncompleteUniPatterns-   | Opt_WarnIncompletePatternsRecUpd-   | Opt_WarnOverflowedLiterals-   | Opt_WarnEmptyEnumerations-   | Opt_WarnMissingFields-   | Opt_WarnMissingImportList-   | Opt_WarnMissingMethods-   | Opt_WarnMissingSignatures-   | Opt_WarnMissingLocalSignatures-   | Opt_WarnNameShadowing-   | Opt_WarnOverlappingPatterns-   | Opt_WarnTypeDefaults-   | Opt_WarnMonomorphism-   | Opt_WarnUnusedTopBinds-   | Opt_WarnUnusedLocalBinds-   | Opt_WarnUnusedPatternBinds-   | Opt_WarnUnusedImports-   | Opt_WarnUnusedMatches-   | Opt_WarnUnusedTypePatterns-   | Opt_WarnUnusedForalls-   | Opt_WarnUnusedRecordWildcards-   | Opt_WarnRedundantRecordWildcards-   | Opt_WarnWarningsDeprecations-   | Opt_WarnDeprecatedFlags-   | Opt_WarnMissingMonadFailInstances -- since 8.0-   | Opt_WarnSemigroup -- since 8.0-   | Opt_WarnDodgyExports-   | Opt_WarnDodgyImports-   | Opt_WarnOrphans-   | Opt_WarnAutoOrphans-   | Opt_WarnIdentities-   | Opt_WarnTabs-   | Opt_WarnUnrecognisedPragmas-   | Opt_WarnDodgyForeignImports-   | Opt_WarnUnusedDoBind-   | Opt_WarnWrongDoBind-   | Opt_WarnAlternativeLayoutRuleTransitional-   | Opt_WarnUnsafe-   | Opt_WarnSafe-   | Opt_WarnTrustworthySafe-   | Opt_WarnMissedSpecs-   | Opt_WarnAllMissedSpecs-   | Opt_WarnUnsupportedCallingConventions-   | Opt_WarnUnsupportedLlvmVersion-   | Opt_WarnMissedExtraSharedLib-   | Opt_WarnInlineRuleShadowing-   | Opt_WarnTypedHoles-   | Opt_WarnPartialTypeSignatures-   | Opt_WarnMissingExportedSignatures-   | Opt_WarnUntickedPromotedConstructors-   | Opt_WarnDerivingTypeable-   | Opt_WarnDeferredTypeErrors-   | Opt_WarnDeferredOutOfScopeVariables-   | Opt_WarnNonCanonicalMonadInstances   -- since 8.0-   | Opt_WarnNonCanonicalMonadFailInstances   -- since 8.0, removed 8.8-   | Opt_WarnNonCanonicalMonoidInstances  -- since 8.0-   | Opt_WarnMissingPatternSynonymSignatures -- since 8.0-   | Opt_WarnUnrecognisedWarningFlags     -- since 8.0-   | Opt_WarnSimplifiableClassConstraints -- Since 8.2-   | Opt_WarnCPPUndef                     -- Since 8.2-   | Opt_WarnUnbangedStrictPatterns       -- Since 8.2-   | Opt_WarnMissingHomeModules           -- Since 8.2-   | Opt_WarnPartialFields                -- Since 8.4-   | Opt_WarnMissingExportList-   | Opt_WarnInaccessibleCode-   | Opt_WarnStarIsType                   -- Since 8.6-   | Opt_WarnStarBinder                   -- Since 8.6-   | Opt_WarnImplicitKindVars             -- Since 8.6-   | Opt_WarnSpaceAfterBang-   | Opt_WarnMissingDerivingStrategies    -- Since 8.8-   | Opt_WarnPrepositiveQualifiedModule   -- Since TBD-   | Opt_WarnUnusedPackages               -- Since 8.10-   | Opt_WarnInferredSafeImports          -- Since 8.10-   | Opt_WarnMissingSafeHaskellMode       -- Since 8.10-   | Opt_WarnDerivingDefaults-   deriving (Eq, Show, Enum)--data Language = Haskell98 | Haskell2010-   deriving (Eq, Enum, Show)--instance Outputable Language where-    ppr = text . show---- | The various Safe Haskell modes-data SafeHaskellMode-   = Sf_None          -- ^ inferred unsafe-   | Sf_Unsafe        -- ^ declared and checked-   | Sf_Trustworthy   -- ^ declared and checked-   | Sf_Safe          -- ^ declared and checked-   | Sf_SafeInferred  -- ^ inferred as safe-   | Sf_Ignore        -- ^ @-fno-safe-haskell@ state-   deriving (Eq)--instance Show SafeHaskellMode where-    show Sf_None         = "None"-    show Sf_Unsafe       = "Unsafe"-    show Sf_Trustworthy  = "Trustworthy"-    show Sf_Safe         = "Safe"-    show Sf_SafeInferred = "Safe-Inferred"-    show Sf_Ignore       = "Ignore"--instance Outputable SafeHaskellMode where-    ppr = text . show---- | Contains not only a collection of 'GeneralFlag's but also a plethora of--- information relating to the compilation of a single file or GHC session-data DynFlags = DynFlags {-  ghcMode               :: GhcMode,-  ghcLink               :: GhcLink,-  hscTarget             :: HscTarget,--  -- formerly Settings-  ghcNameVersion    :: {-# UNPACK #-} !GhcNameVersion,-  fileSettings      :: {-# UNPACK #-} !FileSettings,-  targetPlatform    :: Platform,       -- Filled in by SysTools-  toolSettings      :: {-# UNPACK #-} !ToolSettings,-  platformMisc      :: {-# UNPACK #-} !PlatformMisc,-  platformConstants :: PlatformConstants,-  rawSettings       :: [(String, String)],--  integerLibrary        :: IntegerLibrary,-    -- ^ IntegerGMP or IntegerSimple. Set at configure time, but may be overridden-    --   by GHC-API users. See Note [The integer library] in PrelNames-  llvmConfig            :: LlvmConfig,-    -- ^ N.B. It's important that this field is lazy since we load the LLVM-    -- configuration lazily. See Note [LLVM Configuration] in SysTools.-  verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]-  optLevel              :: Int,         -- ^ Optimisation level-  debugLevel            :: Int,         -- ^ How much debug information to produce-  simplPhases           :: Int,         -- ^ Number of simplifier phases-  maxSimplIterations    :: Int,         -- ^ Max simplifier iterations-  ruleCheck             :: Maybe String,-  inlineCheck           :: Maybe String, -- ^ A prefix to report inlining decisions about-  strictnessBefore      :: [Int],       -- ^ Additional demand analysis--  parMakeCount          :: Maybe Int,   -- ^ The number of modules to compile in parallel-                                        --   in --make mode, where Nothing ==> compile as-                                        --   many in parallel as there are CPUs.--  enableTimeStats       :: Bool,        -- ^ Enable RTS timing statistics?-  ghcHeapSize           :: Maybe Int,   -- ^ The heap size to set.--  maxRelevantBinds      :: Maybe Int,   -- ^ Maximum number of bindings from the type envt-                                        --   to show in type error messages-  maxValidHoleFits      :: Maybe Int,   -- ^ Maximum number of hole fits to show-                                        --   in typed hole error messages-  maxRefHoleFits        :: Maybe Int,   -- ^ Maximum number of refinement hole-                                        --   fits to show in typed hole error-                                        --   messages-  refLevelHoleFits      :: Maybe Int,   -- ^ Maximum level of refinement for-                                        --   refinement hole fits in typed hole-                                        --   error messages-  maxUncoveredPatterns  :: Int,         -- ^ Maximum number of unmatched patterns to show-                                        --   in non-exhaustiveness warnings-  maxPmCheckModels      :: Int,         -- ^ Soft limit on the number of models-                                        --   the pattern match checker checks-                                        --   a pattern against. A safe guard-                                        --   against exponential blow-up.-  simplTickFactor       :: Int,         -- ^ Multiplier for simplifier ticks-  specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr-  specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function-  specConstrRecursive   :: Int,         -- ^ Max number of specialisations for recursive types-                                        --   Not optional; otherwise ForceSpecConstr can diverge.-  binBlobThreshold      :: Word,        -- ^ Binary literals (e.g. strings) whose size is above-                                        --   this threshold will be dumped in a binary file-                                        --   by the assembler code generator (0 to disable)-  liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase-  floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating-                                        --   See CoreMonad.FloatOutSwitches--  liftLamsRecArgs       :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a-                                        --   recursive function.-  liftLamsNonRecArgs    :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a-                                        --   non-recursive function.-  liftLamsKnown         :: Bool,        -- ^ Lambda lift even when this turns a known call-                                        --   into an unknown call.--  cmmProcAlignment      :: Maybe Int,   -- ^ Align Cmm functions at this boundary or use default.--  historySize           :: Int,         -- ^ Simplification history size--  importPaths           :: [FilePath],-  mainModIs             :: Module,-  mainFunIs             :: Maybe String,-  reductionDepth        :: IntWithInf,   -- ^ Typechecker maximum stack depth-  solverIterations      :: IntWithInf,   -- ^ Number of iterations in the constraints solver-                                         --   Typically only 1 is needed--  thisInstalledUnitId   :: InstalledUnitId,-  thisComponentId_      :: Maybe ComponentId,-  thisUnitIdInsts_      :: Maybe [(ModuleName, Module)],--  -- ways-  ways                  :: [Way],       -- ^ Way flags from the command line-  buildTag              :: String,      -- ^ The global \"way\" (e.g. \"p\" for prof)--  -- For object splitting-  splitInfo             :: Maybe (String,Int),--  -- paths etc.-  objectDir             :: Maybe String,-  dylibInstallName      :: Maybe String,-  hiDir                 :: Maybe String,-  hieDir                :: Maybe String,-  stubDir               :: Maybe String,-  dumpDir               :: Maybe String,--  objectSuf             :: String,-  hcSuf                 :: String,-  hiSuf                 :: String,-  hieSuf                :: String,--  canGenerateDynamicToo :: IORef Bool,-  dynObjectSuf          :: String,-  dynHiSuf              :: String,--  outputFile            :: Maybe String,-  dynOutputFile         :: Maybe String,-  outputHi              :: Maybe String,-  dynLibLoader          :: DynLibLoader,--  -- | This is set by 'DriverPipeline.runPipeline' based on where-  --    its output is going.-  dumpPrefix            :: Maybe FilePath,--  -- | Override the 'dumpPrefix' set by 'DriverPipeline.runPipeline'.-  --    Set by @-ddump-file-prefix@-  dumpPrefixForce       :: Maybe FilePath,--  ldInputs              :: [Option],--  includePaths          :: IncludeSpecs,-  libraryPaths          :: [String],-  frameworkPaths        :: [String],    -- used on darwin only-  cmdlineFrameworks     :: [String],    -- ditto--  rtsOpts               :: Maybe String,-  rtsOptsEnabled        :: RtsOptsEnabled,-  rtsOptsSuggestions    :: Bool,--  hpcDir                :: String,      -- ^ Path to store the .mix files--  -- Plugins-  pluginModNames        :: [ModuleName],-  pluginModNameOpts     :: [(ModuleName,String)],-  frontendPluginOpts    :: [String],-    -- ^ the @-ffrontend-opt@ flags given on the command line, in *reverse*-    -- order that they're specified on the command line.-  cachedPlugins         :: [LoadedPlugin],-    -- ^ plugins dynamically loaded after processing arguments. What will be-    -- loaded here is directed by pluginModNames. Arguments are loaded from-    -- pluginModNameOpts. The purpose of this field is to cache the plugins so-    -- they don't have to be loaded each time they are needed.  See-    -- 'DynamicLoading.initializePlugins'.-  staticPlugins            :: [StaticPlugin],-    -- ^ static plugins which do not need dynamic loading. These plugins are-    -- intended to be added by GHC API users directly to this list.-    ---    -- To add dynamically loaded plugins through the GHC API see-    -- 'addPluginModuleName' instead.--  -- GHC API hooks-  hooks                 :: Hooks,--  --  For ghc -M-  depMakefile           :: FilePath,-  depIncludePkgDeps     :: Bool,-  depIncludeCppDeps     :: Bool,-  depExcludeMods        :: [ModuleName],-  depSuffixes           :: [String],--  --  Package flags-  packageDBFlags        :: [PackageDBFlag],-        -- ^ The @-package-db@ flags given on the command line, In-        -- *reverse* order that they're specified on the command line.-        -- This is intended to be applied with the list of "initial"-        -- package databases derived from @GHC_PACKAGE_PATH@; see-        -- 'getPackageConfRefs'.--  ignorePackageFlags    :: [IgnorePackageFlag],-        -- ^ The @-ignore-package@ flags from the command line.-        -- In *reverse* order that they're specified on the command line.-  packageFlags          :: [PackageFlag],-        -- ^ The @-package@ and @-hide-package@ flags from the command-line.-        -- In *reverse* order that they're specified on the command line.-  pluginPackageFlags    :: [PackageFlag],-        -- ^ The @-plugin-package-id@ flags from command line.-        -- In *reverse* order that they're specified on the command line.-  trustFlags            :: [TrustFlag],-        -- ^ The @-trust@ and @-distrust@ flags.-        -- In *reverse* order that they're specified on the command line.-  packageEnv            :: Maybe FilePath,-        -- ^ Filepath to the package environment file (if overriding default)--  pkgDatabase           :: Maybe [PackageDatabase],-        -- ^ Stack of package databases for the target platform.-        ---        -- A "package database" is a misleading name as it is really a Unit-        -- database (cf Note [The identifier lexicon]).-        ---        -- This field is populated by `initPackages`.-        ---        -- 'Nothing' means the databases have never been read from disk. If-        -- `initPackages` is called again, it doesn't reload the databases from-        -- disk.--  pkgState              :: PackageState,-        -- ^ Consolidated unit database built by 'initPackages' from the package-        -- databases in 'pkgDatabase' and flags ('-ignore-package', etc.).-        ---        -- It also contains mapping from module names to actual Modules.--  -- Temporary files-  -- These have to be IORefs, because the defaultCleanupHandler needs to-  -- know what to clean when an exception happens-  filesToClean          :: IORef FilesToClean,-  dirsToClean           :: IORef (Map FilePath FilePath),-  -- The next available suffix to uniquely name a temp file, updated atomically-  nextTempSuffix        :: IORef Int,--  -- Names of files which were generated from -ddump-to-file; used to-  -- track which ones we need to truncate because it's our first run-  -- through-  generatedDumps        :: IORef (Set FilePath),--  -- hsc dynamic flags-  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-  safeHaskell           :: SafeHaskellMode,-  safeInfer             :: Bool,-  safeInferred          :: Bool,-  -- We store the location of where some extension and flags were turned on so-  -- we can produce accurate error messages when Safe Haskell fails due to-  -- them.-  thOnLoc               :: SrcSpan,-  newDerivOnLoc         :: SrcSpan,-  overlapInstLoc        :: SrcSpan,-  incoherentOnLoc       :: SrcSpan,-  pkgTrustOnLoc         :: SrcSpan,-  warnSafeOnLoc         :: SrcSpan,-  warnUnsafeOnLoc       :: SrcSpan,-  trustworthyOnLoc      :: SrcSpan,-  -- Don't change this without updating extensionFlags:-  -- Here we collect the settings of the language extensions-  -- from the command line, the ghci config file and-  -- from interactive :set / :seti commands.-  extensions            :: [OnOff LangExt.Extension],-  -- extensionFlags should always be equal to-  --     flattenExtensionFlags language extensions-  -- LangExt.Extension is defined in libraries/ghc-boot so that it can be used-  -- by template-haskell-  extensionFlags        :: EnumSet LangExt.Extension,--  -- Unfolding control-  -- See Note [Discounts and thresholds] in CoreUnfold-  ufCreationThreshold   :: Int,-  ufUseThreshold        :: Int,-  ufFunAppDiscount      :: Int,-  ufDictDiscount        :: Int,-  ufKeenessFactor       :: Float,-  ufDearOp              :: Int,-  ufVeryAggressive      :: Bool,--  maxWorkerArgs         :: Int,--  ghciHistSize          :: Int,--  -- | MsgDoc output action: use "ErrUtils" instead of this if you can-  log_action            :: LogAction,-  dump_action           :: DumpAction,-  trace_action          :: TraceAction,-  flushOut              :: FlushOut,-  flushErr              :: FlushErr,--  ghcVersionFile        :: Maybe FilePath,-  haddockOptions        :: Maybe String,--  -- | GHCi scripts specified by -ghci-script, in reverse order-  ghciScripts           :: [String],--  -- Output style options-  pprUserLength         :: Int,-  pprCols               :: Int,--  useUnicode            :: Bool,-  useColor              :: OverridingBool,-  canUseColor           :: Bool,-  colScheme             :: Col.Scheme,--  -- | what kind of {-# SCC #-} to add automatically-  profAuto              :: ProfAuto,--  interactivePrint      :: Maybe String,--  nextWrapperNum        :: IORef (ModuleEnv Int),--  -- | Machine dependent flags (-m<blah> stuff)-  sseVersion            :: Maybe SseVersion,-  bmiVersion            :: Maybe BmiVersion,-  avx                   :: Bool,-  avx2                  :: Bool,-  avx512cd              :: Bool, -- Enable AVX-512 Conflict Detection Instructions.-  avx512er              :: Bool, -- Enable AVX-512 Exponential and Reciprocal Instructions.-  avx512f               :: Bool, -- Enable AVX-512 instructions.-  avx512pf              :: Bool, -- Enable AVX-512 PreFetch Instructions.--  -- | Run-time linker information (what options we need, etc.)-  rtldInfo              :: IORef (Maybe LinkerInfo),--  -- | Run-time compiler information-  rtccInfo              :: IORef (Maybe CompilerInfo),--  -- Constants used to control the amount of optimization done.--  -- | Max size, in bytes, of inline array allocations.-  maxInlineAllocSize    :: Int,--  -- | Only inline memcpy if it generates no more than this many-  -- pseudo (roughly: Cmm) instructions.-  maxInlineMemcpyInsns  :: Int,--  -- | Only inline memset if it generates no more than this many-  -- pseudo (roughly: Cmm) instructions.-  maxInlineMemsetInsns  :: Int,--  -- | Reverse the order of error messages in GHC/GHCi-  reverseErrors         :: Bool,--  -- | Limit the maximum number of errors to show-  maxErrors             :: Maybe Int,--  -- | Unique supply configuration for testing build determinism-  initialUnique         :: Int,-  uniqueIncrement       :: Int,--  -- | Temporary: CFG Edge weights for fast iterations-  cfgWeightInfo         :: CfgWeights-}---- | Edge weights to use when generating a CFG from CMM-data CfgWeights-    = CFGWeights-    { uncondWeight :: Int-    , condBranchWeight :: Int-    , switchWeight :: Int-    , callWeight :: Int-    , likelyCondWeight :: Int-    , unlikelyCondWeight :: Int-    , infoTablePenalty :: Int-    , backEdgeBonus :: Int-    }--defaultCfgWeights :: CfgWeights-defaultCfgWeights-    = CFGWeights-    { uncondWeight = 1000-    , condBranchWeight = 800-    , switchWeight = 1-    , callWeight = -10-    , likelyCondWeight = 900-    , unlikelyCondWeight = 300-    , infoTablePenalty = 300-    , backEdgeBonus = 400-    }--parseCfgWeights :: String -> CfgWeights -> CfgWeights-parseCfgWeights s oldWeights =-        foldl' (\cfg (n,v) -> update n v cfg) oldWeights assignments-    where-        assignments = map assignment $ settings s-        update "uncondWeight" n w =-            w {uncondWeight = n}-        update "condBranchWeight" n w =-            w {condBranchWeight = n}-        update "switchWeight" n w =-            w {switchWeight = n}-        update "callWeight" n w =-            w {callWeight = n}-        update "likelyCondWeight" n w =-            w {likelyCondWeight = n}-        update "unlikelyCondWeight" n w =-            w {unlikelyCondWeight = n}-        update "infoTablePenalty" n w =-            w {infoTablePenalty = n}-        update "backEdgeBonus" n w =-            w {backEdgeBonus = n}-        update other _ _-            = panic $ other ++-                      " is not a cfg weight parameter. " ++-                      exampleString-        settings s-            | (s1,rest) <- break (== ',') s-            , null rest-            = [s1]-            | (s1,rest) <- break (== ',') s-            = [s1] ++ settings (drop 1 rest)-#if __GLASGOW_HASKELL__ <= 810-            | otherwise = panic $ "Invalid cfg parameters." ++ exampleString-#endif-        assignment as-            | (name, _:val) <- break (== '=') as-            = (name,read val)-            | otherwise-            = panic $ "Invalid cfg parameters." ++ exampleString--        exampleString = "Example parameters: uncondWeight=1000," ++-            "condBranchWeight=800,switchWeight=0,callWeight=300" ++-            ",likelyCondWeight=900,unlikelyCondWeight=300" ++-            ",infoTablePenalty=300,backEdgeBonus=400"--backendMaintainsCfg :: DynFlags -> Bool-backendMaintainsCfg dflags = case (platformArch $ targetPlatform dflags) of-    -- ArchX86 -- Should work but not tested so disabled currently.-    ArchX86_64 -> True-    _otherwise -> False--class HasDynFlags m where-    getDynFlags :: m DynFlags--{- It would be desirable to have the more generalised--  instance (MonadTrans t, Monad m, HasDynFlags m) => HasDynFlags (t m) where-      getDynFlags = lift getDynFlags--instance definition. However, that definition would overlap with the-`HasDynFlags (GhcT m)` instance. Instead we define instances for a-couple of common Monad transformers explicitly. -}--instance (Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) where-    getDynFlags = lift getDynFlags--instance (Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m) where-    getDynFlags = lift getDynFlags--instance (Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) where-    getDynFlags = lift getDynFlags--instance (Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) where-    getDynFlags = lift getDynFlags--class ContainsDynFlags t where-    extractDynFlags :: t -> DynFlags--data ProfAuto-  = NoProfAuto         -- ^ no SCC annotations added-  | ProfAutoAll        -- ^ top-level and nested functions are annotated-  | ProfAutoTop        -- ^ top-level functions annotated only-  | ProfAutoExports    -- ^ exported functions annotated only-  | ProfAutoCalls      -- ^ annotate call-sites-  deriving (Eq,Enum)--data LlvmTarget = LlvmTarget-  { lDataLayout :: String-  , lCPU        :: String-  , lAttributes :: [String]-  }---- | See Note [LLVM Configuration] in SysTools.-data LlvmConfig = LlvmConfig { llvmTargets :: [(String, LlvmTarget)]-                             , llvmPasses  :: [(Int, String)]-                             }---------------------------------------------------------------------------------- Accessessors from 'DynFlags'---- | "unbuild" a 'Settings' from a 'DynFlags'. This shouldn't be needed in the--- vast majority of code. But GHCi questionably uses this to produce a default--- 'DynFlags' from which to compute a flags diff for printing.-settings :: DynFlags -> Settings-settings dflags = Settings-  { sGhcNameVersion = ghcNameVersion dflags-  , sFileSettings = fileSettings dflags-  , sTargetPlatform = targetPlatform dflags-  , sToolSettings = toolSettings dflags-  , sPlatformMisc = platformMisc dflags-  , sPlatformConstants = platformConstants dflags-  , sRawSettings = rawSettings dflags-  }--programName :: DynFlags -> String-programName dflags = ghcNameVersion_programName $ ghcNameVersion dflags-projectVersion :: DynFlags -> String-projectVersion dflags = ghcNameVersion_projectVersion (ghcNameVersion dflags)-ghcUsagePath          :: DynFlags -> FilePath-ghcUsagePath dflags = fileSettings_ghcUsagePath $ fileSettings dflags-ghciUsagePath         :: DynFlags -> FilePath-ghciUsagePath dflags = fileSettings_ghciUsagePath $ fileSettings dflags-toolDir               :: DynFlags -> Maybe FilePath-toolDir dflags = fileSettings_toolDir $ fileSettings dflags-topDir                :: DynFlags -> FilePath-topDir dflags = fileSettings_topDir $ fileSettings dflags-tmpDir                :: DynFlags -> String-tmpDir dflags = fileSettings_tmpDir $ fileSettings dflags-extraGccViaCFlags     :: DynFlags -> [String]-extraGccViaCFlags dflags = toolSettings_extraGccViaCFlags $ toolSettings dflags-globalPackageDatabasePath   :: DynFlags -> FilePath-globalPackageDatabasePath dflags = fileSettings_globalPackageDatabase $ fileSettings dflags-pgm_L                 :: DynFlags -> String-pgm_L dflags = toolSettings_pgm_L $ toolSettings dflags-pgm_P                 :: DynFlags -> (String,[Option])-pgm_P dflags = toolSettings_pgm_P $ toolSettings dflags-pgm_F                 :: DynFlags -> String-pgm_F dflags = toolSettings_pgm_F $ toolSettings dflags-pgm_c                 :: DynFlags -> String-pgm_c dflags = toolSettings_pgm_c $ toolSettings dflags-pgm_a                 :: DynFlags -> (String,[Option])-pgm_a dflags = toolSettings_pgm_a $ toolSettings dflags-pgm_l                 :: DynFlags -> (String,[Option])-pgm_l dflags = toolSettings_pgm_l $ toolSettings dflags-pgm_dll               :: DynFlags -> (String,[Option])-pgm_dll dflags = toolSettings_pgm_dll $ toolSettings dflags-pgm_T                 :: DynFlags -> String-pgm_T dflags = toolSettings_pgm_T $ toolSettings dflags-pgm_windres           :: DynFlags -> String-pgm_windres dflags = toolSettings_pgm_windres $ toolSettings dflags-pgm_libtool           :: DynFlags -> String-pgm_libtool dflags = toolSettings_pgm_libtool $ toolSettings dflags-pgm_lcc               :: DynFlags -> (String,[Option])-pgm_lcc dflags = toolSettings_pgm_lcc $ toolSettings dflags-pgm_ar                :: DynFlags -> String-pgm_ar dflags = toolSettings_pgm_ar $ toolSettings dflags-pgm_ranlib            :: DynFlags -> String-pgm_ranlib dflags = toolSettings_pgm_ranlib $ toolSettings dflags-pgm_lo                :: DynFlags -> (String,[Option])-pgm_lo dflags = toolSettings_pgm_lo $ toolSettings dflags-pgm_lc                :: DynFlags -> (String,[Option])-pgm_lc dflags = toolSettings_pgm_lc $ toolSettings dflags-pgm_i                 :: DynFlags -> String-pgm_i dflags = toolSettings_pgm_i $ toolSettings dflags-opt_L                 :: DynFlags -> [String]-opt_L dflags = toolSettings_opt_L $ toolSettings dflags-opt_P                 :: DynFlags -> [String]-opt_P dflags = concatMap (wayOptP (targetPlatform dflags)) (ways dflags)-            ++ toolSettings_opt_P (toolSettings dflags)---- This function packages everything that's needed to fingerprint opt_P--- flags. See Note [Repeated -optP hashing].-opt_P_signature       :: DynFlags -> ([String], Fingerprint)-opt_P_signature dflags =-  ( concatMap (wayOptP (targetPlatform dflags)) (ways dflags)-  , toolSettings_opt_P_fingerprint $ toolSettings dflags-  )--opt_F                 :: DynFlags -> [String]-opt_F dflags= toolSettings_opt_F $ toolSettings dflags-opt_c                 :: DynFlags -> [String]-opt_c dflags = concatMap (wayOptc (targetPlatform dflags)) (ways dflags)-            ++ toolSettings_opt_c (toolSettings dflags)-opt_cxx               :: DynFlags -> [String]-opt_cxx dflags= toolSettings_opt_cxx $ toolSettings dflags-opt_a                 :: DynFlags -> [String]-opt_a dflags= toolSettings_opt_a $ toolSettings dflags-opt_l                 :: DynFlags -> [String]-opt_l dflags = concatMap (wayOptl (targetPlatform dflags)) (ways dflags)-            ++ toolSettings_opt_l (toolSettings dflags)-opt_windres           :: DynFlags -> [String]-opt_windres dflags= toolSettings_opt_windres $ toolSettings dflags-opt_lcc                :: DynFlags -> [String]-opt_lcc dflags= toolSettings_opt_lcc $ toolSettings dflags-opt_lo                :: DynFlags -> [String]-opt_lo dflags= toolSettings_opt_lo $ toolSettings dflags-opt_lc                :: DynFlags -> [String]-opt_lc dflags= toolSettings_opt_lc $ toolSettings dflags-opt_i                 :: DynFlags -> [String]-opt_i dflags= toolSettings_opt_i $ toolSettings dflags--tablesNextToCode :: DynFlags -> Bool-tablesNextToCode = platformMisc_tablesNextToCode . platformMisc---- | The directory for this version of ghc in the user's app directory--- (typically something like @~/.ghc/x86_64-linux-7.6.3@)----versionedAppDir :: DynFlags -> MaybeT IO FilePath-versionedAppDir dflags = do-  -- Make sure we handle the case the HOME isn't set (see #11678)-  appdir <- tryMaybeT $ getAppUserDataDirectory (programName dflags)-  return $ appdir </> versionedFilePath dflags--versionedFilePath :: DynFlags -> FilePath-versionedFilePath dflags = uniqueSubdir $ platformMini $ targetPlatform dflags---- | The target code type of the compilation (if any).------ Whenever you change the target, also make sure to set 'ghcLink' to--- something sensible.------ 'HscNothing' can be used to avoid generating any output, however, note--- that:------  * 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.-  | HscAsm         -- ^ Generate assembly using the native code generator.-  | HscLlvm        -- ^ Generate assembly using the llvm code generator.-  | HscInterpreted -- ^ Generate bytecode.  (Requires 'LinkInMemory')-  | HscNothing     -- ^ Don't generate any code.  See notes above.-  deriving (Eq, Show)---- | Will this target result in an object file on the disk?-isObjectTarget :: HscTarget -> Bool-isObjectTarget HscC     = True-isObjectTarget HscAsm   = True-isObjectTarget HscLlvm  = True-isObjectTarget _        = False---- | Does this target retain *all* top-level bindings for a module,--- rather than just the exported bindings, in the TypeEnv and compiled--- code (if any)?  In interpreted mode we do this, so that GHCi can--- call functions inside a module.  In HscNothing mode we also do it,--- so that Haddock can get access to the GlobalRdrEnv for a module--- after typechecking it.-targetRetainsAllBindings :: HscTarget -> Bool-targetRetainsAllBindings HscInterpreted = True-targetRetainsAllBindings HscNothing     = True-targetRetainsAllBindings _              = False---- | The 'GhcMode' tells us whether we're doing multi-module--- compilation (controlled via the "GHC" API) or one-shot--- (single-module) compilation.  This makes a difference primarily to--- the "Finder": in one-shot mode we look for interface files for--- imported modules, but in multi-module mode we look for source files--- in order to check whether they need to be recompiled.-data GhcMode-  = CompManager         -- ^ @\-\-make@, GHCi, etc.-  | OneShot             -- ^ @ghc -c Foo.hs@-  | MkDepend            -- ^ @ghc -M@, see "Finder" for why we need this-  deriving Eq--instance Outputable GhcMode where-  ppr CompManager = text "CompManager"-  ppr OneShot     = text "OneShot"-  ppr MkDepend    = text "MkDepend"--isOneShot :: GhcMode -> Bool-isOneShot OneShot = True-isOneShot _other  = False---- | What to do in the link step, if there is one.-data GhcLink-  = NoLink              -- ^ Don't link at all-  | LinkBinary          -- ^ Link object code into a binary-  | LinkInMemory        -- ^ Use the in-memory dynamic linker (works for both-                        --   bytecode and object code).-  | LinkDynLib          -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)-  | LinkStaticLib       -- ^ Link objects into a static lib-  deriving (Eq, Show)--isNoLink :: GhcLink -> Bool-isNoLink NoLink = True-isNoLink _      = False---- | We accept flags which make packages visible, but how they select--- the package varies; this data type reflects what selection criterion--- is used.-data PackageArg =-      PackageArg String    -- ^ @-package@, by 'PackageName'-    | UnitIdArg UnitId     -- ^ @-package-id@, by 'UnitId'-  deriving (Eq, Show)-instance Outputable PackageArg where-    ppr (PackageArg pn) = text "package" <+> text pn-    ppr (UnitIdArg uid) = text "unit" <+> ppr uid---- | Represents the renaming that may be associated with an exposed--- package, e.g. the @rns@ part of @-package "foo (rns)"@.------ Here are some example parsings of the package flags (where--- a string literal is punned to be a 'ModuleName':------      * @-package foo@ is @ModRenaming True []@---      * @-package foo ()@ is @ModRenaming False []@---      * @-package foo (A)@ is @ModRenaming False [("A", "A")]@---      * @-package foo (A as B)@ is @ModRenaming False [("A", "B")]@---      * @-package foo with (A as B)@ is @ModRenaming True [("A", "B")]@-data ModRenaming = ModRenaming {-    modRenamingWithImplicit :: Bool, -- ^ Bring all exposed modules into scope?-    modRenamings :: [(ModuleName, ModuleName)] -- ^ Bring module @m@ into scope-                                               --   under name @n@.-  } deriving (Eq)-instance Outputable ModRenaming where-    ppr (ModRenaming b rns) = ppr b <+> parens (ppr rns)---- | Flags for manipulating the set of non-broken packages.-newtype IgnorePackageFlag = IgnorePackage String -- ^ @-ignore-package@-  deriving (Eq)---- | Flags for manipulating package trust.-data TrustFlag-  = TrustPackage    String -- ^ @-trust@-  | DistrustPackage String -- ^ @-distrust@-  deriving (Eq)---- | Flags for manipulating packages visibility.-data PackageFlag-  = ExposePackage   String PackageArg ModRenaming -- ^ @-package@, @-package-id@-  | HidePackage     String -- ^ @-hide-package@-  deriving (Eq) -- NB: equality instance is used by packageFlagsChanged--data PackageDBFlag-  = PackageDB PkgDbRef-  | NoUserPackageDB-  | NoGlobalPackageDB-  | ClearPackageDBs-  deriving (Eq)--packageFlagsChanged :: DynFlags -> DynFlags -> Bool-packageFlagsChanged idflags1 idflags0 =-  packageFlags idflags1 /= packageFlags idflags0 ||-  ignorePackageFlags idflags1 /= ignorePackageFlags idflags0 ||-  pluginPackageFlags idflags1 /= pluginPackageFlags idflags0 ||-  trustFlags idflags1 /= trustFlags idflags0 ||-  packageDBFlags idflags1 /= packageDBFlags idflags0 ||-  packageGFlags idflags1 /= packageGFlags idflags0- where-   packageGFlags dflags = map (`gopt` dflags)-     [ Opt_HideAllPackages-     , Opt_HideAllPluginPackages-     , Opt_AutoLinkPackages ]--instance Outputable PackageFlag where-    ppr (ExposePackage n arg rn) = text n <> braces (ppr arg <+> ppr rn)-    ppr (HidePackage str) = text "-hide-package" <+> text str---- | The 'HscTarget' value corresponding to the default way to create--- object files on the current platform.--defaultHscTarget :: Platform -> PlatformMisc -> HscTarget-defaultHscTarget platform pMisc-  | platformUnregisterised platform = HscC-  | platformMisc_ghcWithNativeCodeGen pMisc = HscAsm-  | otherwise = HscLlvm--defaultObjectTarget :: DynFlags -> HscTarget-defaultObjectTarget dflags = defaultHscTarget-  (targetPlatform dflags)-  (platformMisc dflags)--data DynLibLoader-  = Deployable-  | SystemDependent-  deriving Eq--data RtsOptsEnabled-  = RtsOptsNone | RtsOptsIgnore | RtsOptsIgnoreAll | RtsOptsSafeOnly-  | RtsOptsAll-  deriving (Show)--shouldUseColor :: DynFlags -> Bool-shouldUseColor dflags = overrideWith (canUseColor dflags) (useColor dflags)--shouldUseHexWordLiterals :: DynFlags -> Bool-shouldUseHexWordLiterals dflags =-  Opt_HexWordLiterals `EnumSet.member` generalFlags dflags---- | Are we building with @-fPIE@ or @-fPIC@ enabled?-positionIndependent :: DynFlags -> Bool-positionIndependent dflags = gopt Opt_PIC dflags || gopt Opt_PIE dflags---------------------------------------------------------------------------------- Ways---- The central concept of a "way" is that all objects in a given--- program must be compiled in the same "way".  Certain options change--- parameters of the virtual machine, eg. profiling adds an extra word--- to the object header, so profiling objects cannot be linked with--- non-profiling objects.---- After parsing the command-line options, we determine which "way" we--- are building - this might be a combination way, eg. profiling+threaded.---- We then find the "build-tag" associated with this way, and this--- becomes the suffix used to find .hi files and libraries used in--- this compilation.--data Way-  = WayCustom String -- for GHC API clients building custom variants-  | WayThreaded-  | WayDebug-  | WayProf-  | WayEventLog-  | WayDyn-  deriving (Eq, Ord, Show)--allowed_combination :: [Way] -> Bool-allowed_combination way = and [ x `allowedWith` y-                              | x <- way, y <- way, x < y ]-  where-        -- Note ordering in these tests: the left argument is-        -- <= the right argument, according to the Ord instance-        -- on Way above.--        -- dyn is allowed with everything-        _ `allowedWith` WayDyn                  = True-        WayDyn `allowedWith` _                  = True--        -- debug is allowed with everything-        _ `allowedWith` WayDebug                = True-        WayDebug `allowedWith` _                = True--        (WayCustom {}) `allowedWith` _          = True-        WayThreaded `allowedWith` WayProf       = True-        WayThreaded `allowedWith` WayEventLog   = True-        WayProf     `allowedWith` WayEventLog   = True-        _ `allowedWith` _                       = False--mkBuildTag :: [Way] -> String-mkBuildTag ways = concat (intersperse "_" (map wayTag ways))--wayTag :: Way -> String-wayTag (WayCustom xs) = xs-wayTag WayThreaded = "thr"-wayTag WayDebug    = "debug"-wayTag WayDyn      = "dyn"-wayTag WayProf     = "p"-wayTag WayEventLog = "l"--wayRTSOnly :: Way -> Bool-wayRTSOnly (WayCustom {}) = False-wayRTSOnly WayThreaded = True-wayRTSOnly WayDebug    = True-wayRTSOnly WayDyn      = False-wayRTSOnly WayProf     = False-wayRTSOnly WayEventLog = True--wayDesc :: Way -> String-wayDesc (WayCustom xs) = xs-wayDesc WayThreaded = "Threaded"-wayDesc WayDebug    = "Debug"-wayDesc WayDyn      = "Dynamic"-wayDesc WayProf     = "Profiling"-wayDesc WayEventLog = "RTS Event Logging"---- Turn these flags on when enabling this way-wayGeneralFlags :: Platform -> Way -> [GeneralFlag]-wayGeneralFlags _ (WayCustom {}) = []-wayGeneralFlags _ WayThreaded = []-wayGeneralFlags _ WayDebug    = []-wayGeneralFlags _ WayDyn      = [Opt_PIC, Opt_ExternalDynamicRefs]-    -- We could get away without adding -fPIC when compiling the-    -- modules of a program that is to be linked with -dynamic; the-    -- program itself does not need to be position-independent, only-    -- the libraries need to be.  HOWEVER, GHCi links objects into a-    -- .so before loading the .so using the system linker.  Since only-    -- PIC objects can be linked into a .so, we have to compile even-    -- modules of the main program with -fPIC when using -dynamic.-wayGeneralFlags _ WayProf     = [Opt_SccProfilingOn]-wayGeneralFlags _ WayEventLog = []---- Turn these flags off when enabling this way-wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]-wayUnsetGeneralFlags _ (WayCustom {}) = []-wayUnsetGeneralFlags _ WayThreaded = []-wayUnsetGeneralFlags _ WayDebug    = []-wayUnsetGeneralFlags _ WayDyn      = [-- There's no point splitting-                                      -- when we're going to be dynamically-                                      -- linking. Plus it breaks compilation-                                      -- on OSX x86.-                                      Opt_SplitSections]-wayUnsetGeneralFlags _ WayProf     = []-wayUnsetGeneralFlags _ WayEventLog = []--wayOptc :: Platform -> Way -> [String]-wayOptc _ (WayCustom {}) = []-wayOptc platform WayThreaded = case platformOS platform of-                               OSOpenBSD -> ["-pthread"]-                               OSNetBSD  -> ["-pthread"]-                               _         -> []-wayOptc _ WayDebug      = []-wayOptc _ WayDyn        = []-wayOptc _ WayProf       = ["-DPROFILING"]-wayOptc _ WayEventLog   = ["-DTRACING"]--wayOptl :: Platform -> Way -> [String]-wayOptl _ (WayCustom {}) = []-wayOptl platform WayThreaded =-        case platformOS platform of-        OSFreeBSD  -> ["-pthread"]-        OSOpenBSD  -> ["-pthread"]-        OSNetBSD   -> ["-pthread"]-        _          -> []-wayOptl _ WayDebug      = []-wayOptl _ WayDyn        = []-wayOptl _ WayProf       = []-wayOptl _ WayEventLog   = []--wayOptP :: Platform -> Way -> [String]-wayOptP _ (WayCustom {}) = []-wayOptP _ WayThreaded = []-wayOptP _ WayDebug    = []-wayOptP _ WayDyn      = []-wayOptP _ WayProf     = ["-DPROFILING"]-wayOptP _ WayEventLog = ["-DTRACING"]--whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()-whenGeneratingDynamicToo dflags f = ifGeneratingDynamicToo dflags f (return ())--ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a-ifGeneratingDynamicToo dflags f g = generateDynamicTooConditional dflags f g g--whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()-whenCannotGenerateDynamicToo dflags f-    = ifCannotGenerateDynamicToo dflags f (return ())--ifCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a-ifCannotGenerateDynamicToo dflags f g-    = generateDynamicTooConditional dflags g f g--generateDynamicTooConditional :: MonadIO m-                              => DynFlags -> m a -> m a -> m a -> m a-generateDynamicTooConditional dflags canGen cannotGen notTryingToGen-    = if gopt Opt_BuildDynamicToo dflags-      then do let ref = canGenerateDynamicToo dflags-              b <- liftIO $ readIORef ref-              if b then canGen else cannotGen-      else notTryingToGen--dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags-dynamicTooMkDynamicDynFlags dflags0-    = let dflags1 = addWay' WayDyn dflags0-          dflags2 = dflags1 {-                        outputFile = dynOutputFile dflags1,-                        hiSuf = dynHiSuf dflags1,-                        objectSuf = dynObjectSuf dflags1-                    }-          dflags3 = updateWays dflags2-          dflags4 = gopt_unset dflags3 Opt_BuildDynamicToo-      in dflags4---- | Compute the path of the dynamic object corresponding to an object file.-dynamicOutputFile :: DynFlags -> FilePath -> FilePath-dynamicOutputFile dflags outputFile = dynOut outputFile-  where-    dynOut = flip addExtension (dynObjectSuf dflags) . dropExtension----------------------------------------------------------------------------------- | Used by 'GHC.runGhc' to partially initialize a new 'DynFlags' value-initDynFlags :: DynFlags -> IO DynFlags-initDynFlags dflags = do- let -- We can't build with dynamic-too on Windows, as labels before-     -- the fork point are different depending on whether we are-     -- building dynamically or not.-     platformCanGenerateDynamicToo-         = platformOS (targetPlatform dflags) /= OSMinGW32- refCanGenerateDynamicToo <- newIORef platformCanGenerateDynamicToo- refNextTempSuffix <- newIORef 0- refFilesToClean <- newIORef emptyFilesToClean- refDirsToClean <- newIORef Map.empty- refGeneratedDumps <- newIORef Set.empty- refRtldInfo <- newIORef Nothing- refRtccInfo <- newIORef Nothing- wrapperNum <- newIORef emptyModuleEnv- canUseUnicode <- do let enc = localeEncoding-                         str = "‘’"-                     (withCString enc str $ \cstr ->-                          do str' <- peekCString enc cstr-                             return (str == str'))-                         `catchIOError` \_ -> return False- maybeGhcNoUnicodeEnv <- lookupEnv "GHC_NO_UNICODE"- let adjustNoUnicode (Just _) = False-     adjustNoUnicode Nothing = True- let useUnicode' = (adjustNoUnicode maybeGhcNoUnicodeEnv) && canUseUnicode- canUseColor <- stderrSupportsAnsiColors- maybeGhcColorsEnv  <- lookupEnv "GHC_COLORS"- maybeGhcColoursEnv <- lookupEnv "GHC_COLOURS"- let adjustCols (Just env) = Col.parseScheme env-     adjustCols Nothing    = id- let (useColor', colScheme') =-       (adjustCols maybeGhcColoursEnv . adjustCols maybeGhcColorsEnv)-       (useColor dflags, colScheme dflags)- return dflags{-        canGenerateDynamicToo = refCanGenerateDynamicToo,-        nextTempSuffix = refNextTempSuffix,-        filesToClean   = refFilesToClean,-        dirsToClean    = refDirsToClean,-        generatedDumps = refGeneratedDumps,-        nextWrapperNum = wrapperNum,-        useUnicode    = useUnicode',-        useColor      = useColor',-        canUseColor   = canUseColor,-        colScheme     = colScheme',-        rtldInfo      = refRtldInfo,-        rtccInfo      = refRtccInfo-        }---- | 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 -> LlvmConfig -> DynFlags-defaultDynFlags mySettings llvmConfig =--- See Note [Updating flag description in the User's Guide]-     DynFlags {-        ghcMode                 = CompManager,-        ghcLink                 = LinkBinary,-        hscTarget               = defaultHscTarget (sTargetPlatform mySettings) (sPlatformMisc mySettings),-        integerLibrary          = sIntegerLibraryType mySettings,-        verbosity               = 0,-        optLevel                = 0,-        debugLevel              = 0,-        simplPhases             = 2,-        maxSimplIterations      = 4,-        ruleCheck               = Nothing,-        inlineCheck             = Nothing,-        binBlobThreshold        = 500000, -- 500K is a good default (see #16190)-        maxRelevantBinds        = Just 6,-        maxValidHoleFits   = Just 6,-        maxRefHoleFits     = Just 6,-        refLevelHoleFits   = Nothing,-        maxUncoveredPatterns    = 4,-        maxPmCheckModels        = 30,-        simplTickFactor         = 100,-        specConstrThreshold     = Just 2000,-        specConstrCount         = Just 3,-        specConstrRecursive     = 3,-        liberateCaseThreshold   = Just 2000,-        floatLamArgs            = Just 0, -- Default: float only if no fvs-        liftLamsRecArgs         = Just 5, -- Default: the number of available argument hardware registers on x86_64-        liftLamsNonRecArgs      = Just 5, -- Default: the number of available argument hardware registers on x86_64-        liftLamsKnown           = False,  -- Default: don't turn known calls into unknown ones-        cmmProcAlignment        = Nothing,--        historySize             = 20,-        strictnessBefore        = [],--        parMakeCount            = Just 1,--        enableTimeStats         = False,-        ghcHeapSize             = Nothing,--        importPaths             = ["."],-        mainModIs               = mAIN,-        mainFunIs               = Nothing,-        reductionDepth          = treatZeroAsInf mAX_REDUCTION_DEPTH,-        solverIterations        = treatZeroAsInf mAX_SOLVER_ITERATIONS,--        thisInstalledUnitId     = toInstalledUnitId mainUnitId,-        thisUnitIdInsts_        = Nothing,-        thisComponentId_        = Nothing,--        objectDir               = Nothing,-        dylibInstallName        = Nothing,-        hiDir                   = Nothing,-        hieDir                  = Nothing,-        stubDir                 = Nothing,-        dumpDir                 = Nothing,--        objectSuf               = phaseInputExt StopLn,-        hcSuf                   = phaseInputExt HCc,-        hiSuf                   = "hi",-        hieSuf                  = "hie",--        canGenerateDynamicToo   = panic "defaultDynFlags: No canGenerateDynamicToo",-        dynObjectSuf            = "dyn_" ++ phaseInputExt StopLn,-        dynHiSuf                = "dyn_hi",--        pluginModNames          = [],-        pluginModNameOpts       = [],-        frontendPluginOpts      = [],-        cachedPlugins           = [],-        staticPlugins           = [],-        hooks                   = emptyHooks,--        outputFile              = Nothing,-        dynOutputFile           = Nothing,-        outputHi                = Nothing,-        dynLibLoader            = SystemDependent,-        dumpPrefix              = Nothing,-        dumpPrefixForce         = Nothing,-        ldInputs                = [],-        includePaths            = IncludeSpecs [] [],-        libraryPaths            = [],-        frameworkPaths          = [],-        cmdlineFrameworks       = [],-        rtsOpts                 = Nothing,-        rtsOptsEnabled          = RtsOptsSafeOnly,-        rtsOptsSuggestions      = True,--        hpcDir                  = ".hpc",--        packageDBFlags          = [],-        packageFlags            = [],-        pluginPackageFlags      = [],-        ignorePackageFlags      = [],-        trustFlags              = [],-        packageEnv              = Nothing,-        pkgDatabase             = Nothing,-        pkgState                = emptyPackageState,-        ways                    = defaultWays mySettings,-        buildTag                = mkBuildTag (defaultWays mySettings),-        splitInfo               = Nothing,--        ghcNameVersion = sGhcNameVersion mySettings,-        fileSettings = sFileSettings mySettings,-        toolSettings = sToolSettings mySettings,-        targetPlatform = sTargetPlatform mySettings,-        platformMisc = sPlatformMisc mySettings,-        platformConstants = sPlatformConstants mySettings,-        rawSettings = sRawSettings mySettings,--        -- See Note [LLVM configuration].-        llvmConfig              = llvmConfig,--        -- ghc -M values-        depMakefile       = "Makefile",-        depIncludePkgDeps = False,-        depIncludeCppDeps = False,-        depExcludeMods    = [],-        depSuffixes       = [],-        -- end of ghc -M values-        nextTempSuffix = panic "defaultDynFlags: No nextTempSuffix",-        filesToClean   = panic "defaultDynFlags: No filesToClean",-        dirsToClean    = panic "defaultDynFlags: No dirsToClean",-        generatedDumps = panic "defaultDynFlags: No generatedDumps",-        ghcVersionFile = Nothing,-        haddockOptions = Nothing,-        dumpFlags = EnumSet.empty,-        generalFlags = EnumSet.fromList (defaultFlags mySettings),-        warningFlags = EnumSet.fromList standardWarnings,-        fatalWarningFlags = EnumSet.empty,-        ghciScripts = [],-        language = Nothing,-        safeHaskell = Sf_None,-        safeInfer   = True,-        safeInferred = True,-        thOnLoc = noSrcSpan,-        newDerivOnLoc = noSrcSpan,-        overlapInstLoc = noSrcSpan,-        incoherentOnLoc = noSrcSpan,-        pkgTrustOnLoc = noSrcSpan,-        warnSafeOnLoc = noSrcSpan,-        warnUnsafeOnLoc = noSrcSpan,-        trustworthyOnLoc = noSrcSpan,-        extensions = [],-        extensionFlags = flattenExtensionFlags Nothing [],--        -- The ufCreationThreshold threshold must be reasonably high to-        -- take account of possible discounts.-        -- E.g. 450 is not enough in 'fulsom' for Interval.sqr to inline-        -- into Csg.calc (The unfolding for sqr never makes it into the-        -- interface file.)-        ufCreationThreshold = 750,-        ufUseThreshold      = 60,-        ufFunAppDiscount    = 60,-        -- Be fairly keen to inline a function if that means-        -- we'll be able to pick the right method from a dictionary-        ufDictDiscount      = 30,-        ufKeenessFactor     = 1.5,-        ufDearOp            = 40,-        ufVeryAggressive    = False,--        maxWorkerArgs = 10,--        ghciHistSize = 50, -- keep a log of length 50 by default--        -- Logging--        log_action   = defaultLogAction,-        dump_action  = defaultDumpAction,-        trace_action = defaultTraceAction,--        flushOut = defaultFlushOut,-        flushErr = defaultFlushErr,-        pprUserLength = 5,-        pprCols = 100,-        useUnicode = False,-        useColor = Auto,-        canUseColor = False,-        colScheme = Col.defaultScheme,-        profAuto = NoProfAuto,-        interactivePrint = Nothing,-        nextWrapperNum = panic "defaultDynFlags: No nextWrapperNum",-        sseVersion = Nothing,-        bmiVersion = Nothing,-        avx = False,-        avx2 = False,-        avx512cd = False,-        avx512er = False,-        avx512f = False,-        avx512pf = False,-        rtldInfo = panic "defaultDynFlags: no rtldInfo",-        rtccInfo = panic "defaultDynFlags: no rtccInfo",--        maxInlineAllocSize = 128,-        maxInlineMemcpyInsns = 32,-        maxInlineMemsetInsns = 32,--        initialUnique = 0,-        uniqueIncrement = 1,--        reverseErrors = False,-        maxErrors     = Nothing,-        cfgWeightInfo = defaultCfgWeights-      }--defaultWays :: Settings -> [Way]-defaultWays settings = if pc_DYNAMIC_BY_DEFAULT (sPlatformConstants settings)-                       then [WayDyn]-                       else []--interpWays :: [Way]-interpWays-  | dynamicGhc = [WayDyn]-  | rtsIsProfiled = [WayProf]-  | otherwise = []--interpreterProfiled :: DynFlags -> Bool-interpreterProfiled dflags-  | gopt Opt_ExternalInterpreter dflags = gopt Opt_SccProfilingOn dflags-  | otherwise = rtsIsProfiled--interpreterDynamic :: DynFlags -> Bool-interpreterDynamic dflags-  | gopt Opt_ExternalInterpreter dflags = WayDyn `elem` ways dflags-  | otherwise = dynamicGhc---------------------------------------------------------------------------------- Note [JSON Error Messages]------ When the user requests the compiler output to be dumped as json--- we used to collect them all in an IORef and then print them at the end.--- This doesn't work very well with GHCi. (See #14078) So instead we now--- use the simpler method of just outputting a JSON document inplace to--- stdout.------ Before the compiler calls log_action, it has already turned the `ErrMsg`--- into a formatted message. This means that we lose some possible--- information to provide to the user but refactoring log_action is quite--- invasive as it is called in many places. So, for now I left it alone--- and we can refine its behaviour as users request different output.--type FatalMessager = String -> IO ()--type LogAction = DynFlags-              -> WarnReason-              -> Severity-              -> SrcSpan-              -> PprStyle-              -> MsgDoc-              -> IO ()--defaultFatalMessager :: FatalMessager-defaultFatalMessager = hPutStrLn stderr----- See Note [JSON Error Messages]----jsonLogAction :: LogAction-jsonLogAction dflags reason severity srcSpan _style msg-  = do-    defaultLogActionHPutStrDoc dflags stdout (doc $$ text "")-                               (mkCodeStyle CStyle)-    where-      doc = renderJSON $-              JSObject [ ( "span", json srcSpan )-                       , ( "doc" , JSString (showSDoc dflags msg) )-                       , ( "severity", json severity )-                       , ( "reason" ,   json reason )-                       ]---defaultLogAction :: LogAction-defaultLogAction dflags reason severity srcSpan style msg-    = case severity of-      SevOutput      -> printOut msg style-      SevDump        -> printOut (msg $$ blankLine) style-      SevInteractive -> putStrSDoc msg style-      SevInfo        -> printErrs msg style-      SevFatal       -> printErrs msg style-      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--      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- = defaultLogActionHPutStrDoc dflags h (d $$ text "") sty--defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()-defaultLogActionHPutStrDoc dflags h d sty-  -- Don't add a newline at the end, so that successive-  -- calls to this log-action can output all on the same line-  = printSDoc Pretty.PageMode dflags h sty d--newtype FlushOut = FlushOut (IO ())--defaultFlushOut :: FlushOut-defaultFlushOut = FlushOut $ hFlush stdout--newtype FlushErr = FlushErr (IO ())--defaultFlushErr :: FlushErr-defaultFlushErr = FlushErr $ hFlush stderr--{--Note [Verbosity levels]-~~~~~~~~~~~~~~~~~~~~~~~-    0   |   print errors & warnings only-    1   |   minimal verbosity: print "compiling M ... done." for each module.-    2   |   equivalent to -dshow-passes-    3   |   equivalent to existing "ghc -v"-    4   |   "ghc -v -ddump-most"-    5   |   "ghc -v -ddump-all"--}--data OnOff a = On a-             | Off a-  deriving (Eq, Show)--instance Outputable a => Outputable (OnOff a) where-  ppr (On x)  = text "On" <+> ppr x-  ppr (Off x) = text "Off" <+> ppr x---- OnOffs accumulate in reverse order, so we use foldr in order to--- process them in the right order-flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> EnumSet LangExt.Extension-flattenExtensionFlags ml = foldr f defaultExtensionFlags-    where f (On f)  flags = EnumSet.insert f flags-          f (Off f) flags = EnumSet.delete f flags-          defaultExtensionFlags = EnumSet.fromList (languageExtensions ml)---- | The language extensions implied by the various language variants.--- When updating this be sure to update the flag documentation in--- @docs/users-guide/glasgow_exts.rst@.-languageExtensions :: Maybe Language -> [LangExt.Extension]--languageExtensions Nothing-    -- Nothing => the default case-    = LangExt.NondecreasingIndentation -- This has been on by default for some time-    : delete LangExt.DatatypeContexts  -- The Haskell' committee decided to-                                       -- remove datatype contexts from the-                                       -- language:-   -- http://www.haskell.org/pipermail/haskell-prime/2011-January/003335.html-      (languageExtensions (Just Haskell2010))--   -- NB: MonoPatBinds is no longer the default--languageExtensions (Just Haskell98)-    = [LangExt.ImplicitPrelude,-       -- See Note [When is StarIsType enabled]-       LangExt.StarIsType,-       LangExt.CUSKs,-       LangExt.MonomorphismRestriction,-       LangExt.NPlusKPatterns,-       LangExt.DatatypeContexts,-       LangExt.TraditionalRecordSyntax,-       LangExt.NondecreasingIndentation-           -- strictly speaking non-standard, but we always had this-           -- on implicitly before the option was added in 7.1, and-           -- turning it off breaks code, so we're keeping it on for-           -- backwards compatibility.  Cabal uses -XHaskell98 by-           -- default unless you specify another language.-      ]--languageExtensions (Just Haskell2010)-    = [LangExt.ImplicitPrelude,-       -- See Note [When is StarIsType enabled]-       LangExt.StarIsType,-       LangExt.CUSKs,-       LangExt.MonomorphismRestriction,-       LangExt.DatatypeContexts,-       LangExt.TraditionalRecordSyntax,-       LangExt.EmptyDataDecls,-       LangExt.ForeignFunctionInterface,-       LangExt.PatternGuards,-       LangExt.DoAndIfThenElse,-       LangExt.RelaxedPolyRec]--hasPprDebug :: DynFlags -> Bool-hasPprDebug = dopt Opt_D_ppr_debug--hasNoDebugOutput :: DynFlags -> Bool-hasNoDebugOutput = dopt Opt_D_no_debug_output--hasNoStateHack :: DynFlags -> Bool-hasNoStateHack = gopt Opt_G_NoStateHack--hasNoOptCoercion :: DynFlags -> Bool-hasNoOptCoercion = gopt Opt_G_NoOptCoercion----- | Test whether a 'DumpFlag' is set-dopt :: DumpFlag -> DynFlags -> Bool-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-          enableIfVerbose Opt_D_dump_cs_trace               = False-          enableIfVerbose Opt_D_dump_if_trace               = False-          enableIfVerbose Opt_D_dump_vt_trace               = False-          enableIfVerbose Opt_D_dump_tc                     = False-          enableIfVerbose Opt_D_dump_rn                     = False-          enableIfVerbose Opt_D_dump_rn_stats               = False-          enableIfVerbose Opt_D_dump_hi_diffs               = False-          enableIfVerbose Opt_D_verbose_core2core           = False-          enableIfVerbose Opt_D_verbose_stg2stg             = False-          enableIfVerbose Opt_D_dump_splices                = False-          enableIfVerbose Opt_D_th_dec_file                 = False-          enableIfVerbose Opt_D_dump_rule_firings           = False-          enableIfVerbose Opt_D_dump_rule_rewrites          = False-          enableIfVerbose Opt_D_dump_simpl_trace            = False-          enableIfVerbose Opt_D_dump_rtti                   = False-          enableIfVerbose Opt_D_dump_inlinings              = False-          enableIfVerbose Opt_D_dump_core_stats             = False-          enableIfVerbose Opt_D_dump_asm_stats              = False-          enableIfVerbose Opt_D_dump_types                  = False-          enableIfVerbose Opt_D_dump_simpl_iterations       = False-          enableIfVerbose Opt_D_dump_ticked                 = False-          enableIfVerbose Opt_D_dump_view_pattern_commoning = False-          enableIfVerbose Opt_D_dump_mod_cycles             = False-          enableIfVerbose Opt_D_dump_mod_map                = False-          enableIfVerbose Opt_D_dump_ec_trace               = False-          enableIfVerbose _                                 = True---- | Set a 'DumpFlag'-dopt_set :: DynFlags -> DumpFlag -> DynFlags-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 = EnumSet.delete f (dumpFlags dfs) }---- | Test whether a 'GeneralFlag' is set-gopt :: GeneralFlag -> DynFlags -> Bool-gopt f dflags  = f `EnumSet.member` generalFlags dflags---- | Set a 'GeneralFlag'-gopt_set :: DynFlags -> GeneralFlag -> DynFlags-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 = EnumSet.delete f (generalFlags dfs) }---- | Test whether a 'WarningFlag' is set-wopt :: WarningFlag -> DynFlags -> Bool-wopt f dflags  = f `EnumSet.member` warningFlags dflags---- | Set a 'WarningFlag'-wopt_set :: DynFlags -> WarningFlag -> DynFlags-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 = EnumSet.delete f (warningFlags dfs) }---- | Test whether a 'WarningFlag' is set as fatal-wopt_fatal :: WarningFlag -> DynFlags -> Bool-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 = EnumSet.insert f (fatalWarningFlags dfs) }---- | Mark a 'WarningFlag' as not fatal-wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags-wopt_unset_fatal dfs f-    = dfs { fatalWarningFlags = EnumSet.delete f (fatalWarningFlags dfs) }---- | Test whether a 'LangExt.Extension' is set-xopt :: LangExt.Extension -> DynFlags -> Bool-xopt f dflags = f `EnumSet.member` extensionFlags dflags---- | Set a 'LangExt.Extension'-xopt_set :: DynFlags -> LangExt.Extension -> DynFlags-xopt_set dfs f-    = let onoffs = On f : extensions dfs-      in dfs { extensions = onoffs,-               extensionFlags = flattenExtensionFlags (language dfs) onoffs }---- | Unset a 'LangExt.Extension'-xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags-xopt_unset dfs f-    = let onoffs = Off f : extensions dfs-      in dfs { extensions = onoffs,-               extensionFlags = flattenExtensionFlags (language dfs) onoffs }---- | Set or unset a 'LangExt.Extension', unless it has been explicitly---   set or unset before.-xopt_set_unlessExplSpec-        :: LangExt.Extension-        -> (DynFlags -> LangExt.Extension -> DynFlags)-        -> DynFlags -> DynFlags-xopt_set_unlessExplSpec ext setUnset dflags =-    let referedExts = stripOnOff <$> extensions dflags-        stripOnOff (On x)  = x-        stripOnOff (Off x) = x-    in-        if ext `elem` referedExts then dflags else setUnset dflags ext--lang_set :: DynFlags -> Maybe Language -> DynFlags-lang_set dflags lang =-   dflags {-            language = lang,-            extensionFlags = flattenExtensionFlags lang (extensions dflags)-          }---- | An internal helper to check whether to use unicode syntax for output.------ Note: You should very likely be using 'Outputable.unicodeSyntax' instead--- of this function.-useUnicodeSyntax :: DynFlags -> Bool-useUnicodeSyntax = gopt Opt_PrintUnicodeSyntax--useStarIsType :: DynFlags -> Bool-useStarIsType = xopt LangExt.StarIsType---- | Set the Haskell language standard to use-setLanguage :: Language -> DynP ()-setLanguage l = upd (`lang_set` Just l)---- | Some modules have dependencies on others through the DynFlags rather than textual imports-dynFlagDependencies :: DynFlags -> [ModuleName]-dynFlagDependencies = pluginModNames---- | Is the -fpackage-trust mode on-packageTrustOn :: DynFlags -> Bool-packageTrustOn = gopt Opt_PackageTrust---- | Is Safe Haskell on in some way (including inference mode)-safeHaskellOn :: DynFlags -> Bool-safeHaskellOn dflags = safeHaskellModeEnabled dflags || safeInferOn dflags--safeHaskellModeEnabled :: DynFlags -> Bool-safeHaskellModeEnabled dflags = safeHaskell dflags `elem` [Sf_Unsafe, Sf_Trustworthy-                                                   , Sf_Safe ]----- | Is the Safe Haskell safe language in use-safeLanguageOn :: DynFlags -> Bool-safeLanguageOn dflags = safeHaskell dflags == Sf_Safe---- | Is the Safe Haskell safe inference mode active-safeInferOn :: DynFlags -> Bool-safeInferOn = safeInfer---- | Test if Safe Imports are on in some form-safeImportsOn :: DynFlags -> Bool-safeImportsOn dflags = safeHaskell dflags == Sf_Unsafe ||-                       safeHaskell dflags == Sf_Trustworthy ||-                       safeHaskell dflags == Sf_Safe---- | Set a 'Safe Haskell' flag-setSafeHaskell :: SafeHaskellMode -> DynP ()-setSafeHaskell s = updM f-    where f dfs = do-              let sf = safeHaskell dfs-              safeM <- combineSafeFlags sf s-              case s of-                Sf_Safe -> return $ dfs { safeHaskell = safeM, safeInfer = False }-                -- leave safe inferrence on in Trustworthy mode so we can warn-                -- if it could have been inferred safe.-                Sf_Trustworthy -> do-                  l <- getCurLoc-                  return $ dfs { safeHaskell = safeM, trustworthyOnLoc = l }-                -- leave safe inference on in Unsafe mode as well.-                _ -> return $ dfs { safeHaskell = safeM }---- | Are all direct imports required to be safe for this Safe Haskell mode?--- Direct imports are when the code explicitly imports a module-safeDirectImpsReq :: DynFlags -> Bool-safeDirectImpsReq d = safeLanguageOn d---- | Are all implicit imports required to be safe for this Safe Haskell mode?--- Implicit imports are things in the prelude. e.g System.IO when print is used.-safeImplicitImpsReq :: DynFlags -> Bool-safeImplicitImpsReq d = safeLanguageOn d---- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.--- This makes Safe Haskell very much a monoid but for now I prefer this as I don't--- want to export this functionality from the module but do want to export the--- type constructors.-combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode-combineSafeFlags a b | a == Sf_None         = return b-                     | b == Sf_None         = return a-                     | a == Sf_Ignore || b == Sf_Ignore = return Sf_Ignore-                     | a == b               = return a-                     | otherwise            = addErr errm >> pure a-    where errm = "Incompatible Safe Haskell flags! ("-                    ++ show a ++ ", " ++ show b ++ ")"---- | A list of unsafe flags under Safe Haskell. Tuple elements are:---     * name of the flag---     * function to get srcspan that enabled the flag---     * function to test if the flag is on---     * function to turn the flag off-unsafeFlags, unsafeFlagsForInfer-  :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]-unsafeFlags = [ ("-XGeneralizedNewtypeDeriving", newDerivOnLoc,-                    xopt LangExt.GeneralizedNewtypeDeriving,-                    flip xopt_unset LangExt.GeneralizedNewtypeDeriving)-              , ("-XTemplateHaskell", thOnLoc,-                    xopt LangExt.TemplateHaskell,-                    flip xopt_unset LangExt.TemplateHaskell)-              ]-unsafeFlagsForInfer = unsafeFlags----- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order-getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from-        -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors-        -> [a]                  -- ^ Correctly ordered extracted options-getOpts dflags opts = reverse (opts dflags)-        -- We add to the options from the front, so we need to reverse the list---- | Gets the verbosity flag for the current verbosity level. This is fed to--- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included-getVerbFlags :: DynFlags -> [String]-getVerbFlags dflags-  | verbosity dflags >= 4 = ["-v"]-  | otherwise             = []--setObjectDir, setHiDir, setHieDir, setStubDir, setDumpDir, setOutputDir,-         setDynObjectSuf, setDynHiSuf,-         setDylibInstallName,-         setObjectSuf, setHiSuf, setHieSuf, setHcSuf, parseDynLibLoaderMode,-         setPgmP, addOptl, addOptc, addOptcxx, addOptP,-         addCmdlineFramework, addHaddockOpts, addGhciScript,-         setInteractivePrint-   :: String -> DynFlags -> DynFlags-setOutputFile, setDynOutputFile, setOutputHi, setDumpPrefixForce-   :: Maybe String -> DynFlags -> DynFlags--setObjectDir  f d = d { objectDir  = Just f}-setHiDir      f d = d { hiDir      = Just f}-setHieDir     f d = d { hieDir     = Just f}-setStubDir    f d = d { stubDir    = Just f-                      , includePaths = addGlobalInclude (includePaths d) [f] }-  -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file-  -- \#included from the .hc file when compiling via C (i.e. unregisterised-  -- builds).-setDumpDir    f d = d { dumpDir    = Just f}-setOutputDir  f = setObjectDir f-                . setHieDir f-                . setHiDir f-                . setStubDir f-                . setDumpDir f-setDylibInstallName  f d = d { dylibInstallName = Just f}--setObjectSuf    f d = d { objectSuf    = f}-setDynObjectSuf f d = d { dynObjectSuf = f}-setHiSuf        f d = d { hiSuf        = f}-setHieSuf       f d = d { hieSuf       = f}-setDynHiSuf     f d = d { dynHiSuf     = f}-setHcSuf        f d = d { hcSuf        = f}--setOutputFile f d = d { outputFile = f}-setDynOutputFile f d = d { dynOutputFile = f}-setOutputHi   f d = d { outputHi   = f}--setJsonLogAction :: DynFlags -> DynFlags-setJsonLogAction d = d { log_action = jsonLogAction }--thisComponentId :: DynFlags -> ComponentId-thisComponentId dflags =-  case thisComponentId_ dflags of-    Just cid -> cid-    Nothing  ->-      case thisUnitIdInsts_ dflags of-        Just _  ->-          throwGhcException $ CmdLineError ("Use of -instantiated-with requires -this-component-id")-        Nothing -> ComponentId (unitIdFS (thisPackage dflags))--thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]-thisUnitIdInsts dflags =-    case thisUnitIdInsts_ dflags of-        Just insts -> insts-        Nothing    -> []--thisPackage :: DynFlags -> UnitId-thisPackage dflags =-    case thisUnitIdInsts_ dflags of-        Nothing -> default_uid-        Just insts-          | all (\(x,y) -> mkHoleModule x == y) insts-          -> newUnitId (thisComponentId dflags) insts-          | otherwise-          -> default_uid-  where-    default_uid = DefiniteUnitId (DefUnitId (thisInstalledUnitId dflags))--parseUnitIdInsts :: String -> [(ModuleName, Module)]-parseUnitIdInsts str = case filter ((=="").snd) (readP_to_S parse str) of-    [(r, "")] -> r-    _ -> throwGhcException $ CmdLineError ("Can't parse -instantiated-with: " ++ str)-  where parse = sepBy parseEntry (R.char ',')-        parseEntry = do-            n <- parseModuleName-            _ <- R.char '='-            m <- parseModuleId-            return (n, m)--setUnitIdInsts :: String -> DynFlags -> DynFlags-setUnitIdInsts s d =-    d { thisUnitIdInsts_ = Just (parseUnitIdInsts s) }--setComponentId :: String -> DynFlags -> DynFlags-setComponentId s d =-    d { thisComponentId_ = Just (ComponentId (fsLit s)) }--addPluginModuleName :: String -> DynFlags -> DynFlags-addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }--clearPluginModuleNames :: DynFlags -> DynFlags-clearPluginModuleNames d =-    d { pluginModNames = []-      , pluginModNameOpts = []-      , cachedPlugins = [] }--addPluginModuleNameOption :: String -> DynFlags -> DynFlags-addPluginModuleNameOption optflag d = d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }-  where (m, rest) = break (== ':') optflag-        option = case rest of-          [] -> "" -- should probably signal an error-          (_:plug_opt) -> plug_opt -- ignore the ':' from break--addFrontendPluginOption :: String -> DynFlags -> DynFlags-addFrontendPluginOption s d = d { frontendPluginOpts = s : frontendPluginOpts d }--parseDynLibLoaderMode f d =- case splitAt 8 f of-   ("deploy", "")       -> d { dynLibLoader = Deployable }-   ("sysdep", "")       -> d { dynLibLoader = SystemDependent }-   _                    -> throwGhcException (CmdLineError ("Unknown dynlib loader: " ++ f))--setDumpPrefixForce f d = d { dumpPrefixForce = f}---- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]--- Config.hs should really use Option.-setPgmP   f = alterToolSettings (\s -> s { toolSettings_pgm_P   = (pgm, map Option args)})-  where (pgm:args) = words f-addOptl   f = alterToolSettings (\s -> s { toolSettings_opt_l   = f : toolSettings_opt_l s})-addOptc   f = alterToolSettings (\s -> s { toolSettings_opt_c   = f : toolSettings_opt_c s})-addOptcxx f = alterToolSettings (\s -> s { toolSettings_opt_cxx = f : toolSettings_opt_cxx s})-addOptP   f = alterToolSettings $ \s -> s-          { toolSettings_opt_P   = f : toolSettings_opt_P s-          , toolSettings_opt_P_fingerprint = fingerprintStrings (f : toolSettings_opt_P s)-          }-          -- See Note [Repeated -optP hashing]-  where-  fingerprintStrings ss = fingerprintFingerprints $ map fingerprintString ss---setDepMakefile :: FilePath -> DynFlags -> DynFlags-setDepMakefile f d = d { depMakefile = f }--setDepIncludeCppDeps :: Bool -> DynFlags -> DynFlags-setDepIncludeCppDeps b d = d { depIncludeCppDeps = b }--setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags-setDepIncludePkgDeps b d = d { depIncludePkgDeps = b }--addDepExcludeMod :: String -> DynFlags -> DynFlags-addDepExcludeMod m d-    = d { depExcludeMods = mkModuleName m : depExcludeMods d }--addDepSuffix :: FilePath -> DynFlags -> DynFlags-addDepSuffix s d = d { depSuffixes = s : depSuffixes d }--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}--setInteractivePrint f d = d { interactivePrint = Just f}---------------------------------------------------------------------------------- Setting the optimisation level--updOptLevel :: Int -> DynFlags -> DynFlags--- ^ Sets the 'DynFlags' to be appropriate to the optimisation level-updOptLevel n dfs-  = dfs2{ optLevel = final_n }-  where-   final_n = max 0 (min 2 n)    -- Clamp to 0 <= n <= 2-   dfs1 = foldr (flip gopt_unset) dfs  remove_gopts-   dfs2 = foldr (flip gopt_set)   dfs1 extra_gopts--   extra_gopts  = [ f | (ns,f) <- optLevelFlags, final_n `elem` ns ]-   remove_gopts = [ f | (ns,f) <- optLevelFlags, final_n `notElem` ns ]--{- **********************************************************************-%*                                                                      *-                DynFlags parser-%*                                                                      *-%********************************************************************* -}---- -------------------------------------------------------------------------------- Parsing the dynamic flags.----- | Parse dynamic flags from a list of command line arguments.  Returns--- the parsed 'DynFlags', the left-over arguments, and a list of warnings.--- 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], [Warn])-                            -- ^ Updated 'DynFlags', left-over arguments, and-                            -- list of warnings.-parseDynamicFlagsCmdLine = parseDynamicFlagsFull flagsAll True----- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags--- (-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], [Warn])-                          -- ^ Updated 'DynFlags', left-over arguments, and-                          -- list of warnings.-parseDynamicFilePragma = parseDynamicFlagsFull flagsDynamic False----- | Parses the dynamically set flags for GHC. This is the most general form of--- the dynamic flag parser that the other methods simply wrap. It allows--- saying which flags are valid flags and indicating if we are parsing--- arguments from the command line or from a file pragma.-parseDynamicFlagsFull :: MonadIO m-                  => [Flag (CmdLineP DynFlags)]    -- ^ valid flags to match against-                  -> Bool                          -- ^ are the arguments from the command line?-                  -> DynFlags                      -- ^ current dynamic flags-                  -> [Located String]              -- ^ arguments to parse-                  -> 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) . errMsg) $ errs--  -- check for disabled flags in safe haskell-  let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1-      dflags3 = updateWays dflags2-      theWays = ways dflags3--  unless (allowed_combination theWays) $ liftIO $-      throwGhcExceptionIO (CmdLineError ("combination not supported: " ++-                               intercalate "/" (map wayDesc theWays)))--  let chooseOutput-        | isJust (outputFile dflags3)          -- Only iff user specified -o ...-        , not (isJust (dynOutputFile dflags3)) -- but not -dyno-        = return $ dflags3 { dynOutputFile = Just $ dynamicOutputFile dflags3 outFile }-        | otherwise-        = return dflags3-        where-          outFile = fromJust $ outputFile dflags3-  dflags4 <- ifGeneratingDynamicToo dflags3 chooseOutput (return dflags3)--  let (dflags5, consistency_warnings) = makeDynFlagsConsistent dflags4--  -- Set timer stats & heap size-  when (enableTimeStats dflags5) $ liftIO enableTimingStats-  case (ghcHeapSize dflags5) of-    Just x -> liftIO (setHeapSize x)-    _      -> return ()--  liftIO $ setUnsafeGlobalDynFlags dflags5--  let warns' = map (Warn Cmd.NoReason) (consistency_warnings ++ sh_warns)--  return (dflags5, leftover, warns' ++ warns)---- | Write an error or warning to the 'LogOutput'.-putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle-          -> MsgDoc -> IO ()-putLogMsg dflags = log_action dflags dflags--updateWays :: DynFlags -> DynFlags-updateWays dflags-    = let theWays = sort $ nub $ ways dflags-      in dflags {-             ways        = theWays,-             buildTag    = mkBuildTag (filter (not . wayRTSOnly) theWays)-         }---- | Check (and potentially disable) any extensions that aren't allowed--- in safe mode.------ The bool is to indicate if we are parsing command line flags (false means--- file pragma). This allows us to generate better warnings.-safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])-safeFlagCheck _ dflags | safeLanguageOn dflags = (dflagsUnset, warns)-  where-    -- Handle illegal flags under safe language.-    (dflagsUnset, warns) = foldl' check_method (dflags, []) unsafeFlags--    check_method (df, warns) (str,loc,test,fix)-        | test df   = (fix df, warns ++ safeFailure (loc df) str)-        | otherwise = (df, warns)--    safeFailure loc str-       = [L loc $ str ++ " is not allowed in Safe Haskell; ignoring "-           ++ str]--safeFlagCheck cmdl dflags =-  case (safeInferOn dflags) of-    True | safeFlags -> (dflags', warn)-    True             -> (dflags' { safeInferred = False }, warn)-    False            -> (dflags', warn)--  where-    -- dynflags and warn for when -fpackage-trust by itself with no safe-    -- haskell flag-    (dflags', warn)-      | not (safeHaskellModeEnabled dflags) && not cmdl && packageTrustOn dflags-      = (gopt_unset dflags Opt_PackageTrust, pkgWarnMsg)-      | otherwise = (dflags, [])--    pkgWarnMsg = [L (pkgTrustOnLoc dflags') $-                    "-fpackage-trust ignored;" ++-                    " must be specified with a Safe Haskell flag"]--    -- Have we inferred Unsafe? See Note [HscMain . Safe Haskell Inference]-    safeFlags = all (\(_,_,t,_) -> not $ t dflags) unsafeFlagsForInfer---{- **********************************************************************-%*                                                                      *-                DynFlags specifications-%*                                                                      *-%********************************************************************* -}---- | All dynamic flags option strings without the deprecated ones.--- These are the user facing strings for enabling and disabling options.-allNonDeprecatedFlags :: [String]-allNonDeprecatedFlags = allFlagsDeps False---- | All flags with possibility to filter deprecated ones-allFlagsDeps :: Bool -> [String]-allFlagsDeps keepDeprecated = [ '-':flagName flag-                              | (deprecated, flag) <- flagsAllDeps-                              , keepDeprecated || not (isDeprecated deprecated)]-  where isDeprecated Deprecated = True-        isDeprecated _ = False--{-- - Below we export user facing symbols for GHC dynamic flags for use with the- - GHC API.- -}---- All dynamic flags present in GHC.-flagsAll :: [Flag (CmdLineP DynFlags)]-flagsAll = map snd flagsAllDeps---- All dynamic flags present in GHC with deprecation information.-flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]-flagsAllDeps =  package_flags_deps ++ dynamic_flags_deps----- All dynamic flags, minus package flags, present in GHC.-flagsDynamic :: [Flag (CmdLineP DynFlags)]-flagsDynamic = map snd dynamic_flags_deps---- ALl package flags present in GHC.-flagsPackage :: [Flag (CmdLineP DynFlags)]-flagsPackage = map snd package_flags_deps------------------Helpers to make flags and keep deprecation information------------type FlagMaker m = String -> OptKind m -> Flag m-type DynFlagMaker = FlagMaker (CmdLineP DynFlags)-data Deprecation = NotDeprecated | Deprecated deriving (Eq, Ord)---- Make a non-deprecated flag-make_ord_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags)-              -> (Deprecation, Flag (CmdLineP DynFlags))-make_ord_flag fm name kind = (NotDeprecated, fm name kind)---- Make a deprecated flag-make_dep_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags) -> String-                 -> (Deprecation, Flag (CmdLineP DynFlags))-make_dep_flag fm name kind message = (Deprecated,-                                      fm name $ add_dep_message kind message)--add_dep_message :: OptKind (CmdLineP DynFlags) -> String-                -> OptKind (CmdLineP DynFlags)-add_dep_message (NoArg f) message = NoArg $ f >> deprecate message-add_dep_message (HasArg f) message = HasArg $ \s -> f s >> deprecate message-add_dep_message (SepArg f) message = SepArg $ \s -> f s >> deprecate message-add_dep_message (Prefix f) message = Prefix $ \s -> f s >> deprecate message-add_dep_message (OptPrefix f) message =-                                  OptPrefix $ \s -> f s >> deprecate message-add_dep_message (OptIntSuffix f) message =-                               OptIntSuffix $ \oi -> f oi >> deprecate message-add_dep_message (IntSuffix f) message =-                                  IntSuffix $ \i -> f i >> deprecate message-add_dep_message (FloatSuffix f) message =-                                FloatSuffix $ \fl -> f fl >> deprecate message-add_dep_message (PassFlag f) message =-                                   PassFlag $ \s -> f s >> deprecate message-add_dep_message (AnySuffix f) message =-                                  AnySuffix $ \s -> f s >> deprecate message------------------------- The main flags themselves --------------------------------- See Note [Updating flag description in the User's Guide]--- See Note [Supporting CLI completion]-dynamic_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]-dynamic_flags_deps = [-    make_dep_flag defFlag "n" (NoArg $ return ())-        "The -n flag is deprecated and no longer has any effect"-  , make_ord_flag defFlag "cpp"      (NoArg (setExtensionFlag LangExt.Cpp))-  , make_ord_flag defFlag "F"        (NoArg (setGeneralFlag Opt_Pp))-  , (Deprecated, defFlag "#include"-      (HasArg (\_s ->-         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-        (\n -> case n of-                 Just n-                     | n > 0     -> upd (\d -> d { parMakeCount = Just n })-                     | otherwise -> addErr "Syntax: -j[n] where n > 0"-                 Nothing -> upd (\d -> d { parMakeCount = Nothing })))-                 -- When the number of parallel builds-                 -- is omitted, it is the same-                 -- as specifying that the number of-                 -- parallel builds is equal to the-                 -- result of getNumProcessors-  , make_ord_flag defFlag "instantiated-with"   (sepArg setUnitIdInsts)-  , make_ord_flag defFlag "this-component-id"   (sepArg setComponentId)--    -- RTS options --------------------------------------------------------------  , make_ord_flag defFlag "H"           (HasArg (\s -> upd (\d ->-          d { ghcHeapSize = Just $ fromIntegral (decodeSize s)})))--  , make_ord_flag defFlag "Rghc-timing" (NoArg (upd (\d ->-                                               d { enableTimeStats = True })))--    ------- ways ----------------------------------------------------------------  , make_ord_flag defGhcFlag "prof"           (NoArg (addWay WayProf))-  , make_ord_flag defGhcFlag "eventlog"       (NoArg (addWay WayEventLog))-  , make_ord_flag defGhcFlag "debug"          (NoArg (addWay WayDebug))-  , make_ord_flag defGhcFlag "threaded"       (NoArg (addWay WayThreaded))--  , make_ord_flag defGhcFlag "ticky"-      (NoArg (setGeneralFlag Opt_Ticky >> addWay WayDebug))--    -- -ticky enables ticky-ticky code generation, and also implies -debug which-    -- is required to get the RTS ticky support.--        ----- Linker ---------------------------------------------------------  , make_ord_flag defGhcFlag "static"         (NoArg removeWayDyn)-  , make_ord_flag defGhcFlag "dynamic"        (NoArg (addWay WayDyn))-  , make_ord_flag defGhcFlag "rdynamic" $ noArg $-#if defined(linux_HOST_OS)-                              addOptl "-rdynamic"-#elif defined(mingw32_HOST_OS)-                              addOptl "-Wl,--export-all-symbols"-#else-    -- ignored for compat w/ gcc:-                              id-#endif-  , make_ord_flag defGhcFlag "relative-dynlib-paths"-      (NoArg (setGeneralFlag Opt_RelativeDynlibPaths))-  , make_ord_flag defGhcFlag "copy-libs-when-linking"-      (NoArg (setGeneralFlag Opt_SingleLibFolder))-  , make_ord_flag defGhcFlag "pie"            (NoArg (setGeneralFlag Opt_PICExecutable))-  , make_ord_flag defGhcFlag "no-pie"         (NoArg (unSetGeneralFlag Opt_PICExecutable))--        ------- Specific phases  ---------------------------------------------    -- need to appear before -pgmL to be parsed as LLVM flags.-  , make_ord_flag defFlag "pgmlo"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_lo  = (f,[]) }-  , make_ord_flag defFlag "pgmlc"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_lc  = (f,[]) }-  , make_ord_flag defFlag "pgmi"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_i   =  f }-  , make_ord_flag defFlag "pgmL"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_L   = f }-  , make_ord_flag defFlag "pgmP"-      (hasArg setPgmP)-  , make_ord_flag defFlag "pgmF"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_F   = f }-  , make_ord_flag defFlag "pgmc"-      $ hasArg $ \f -> alterToolSettings $ \s -> s-         { toolSettings_pgm_c   = f-         , -- Don't pass -no-pie with -pgmc-           -- (see #15319)-           toolSettings_ccSupportsNoPie = False-         }-  , make_ord_flag defFlag "pgms"-      (HasArg (\_ -> addWarn "Object splitting was removed in GHC 8.8"))-  , make_ord_flag defFlag "pgma"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_a   = (f,[]) }-  , make_ord_flag defFlag "pgml"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_l   = (f,[]) }-  , make_ord_flag defFlag "pgmdll"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_dll = (f,[]) }-  , make_ord_flag defFlag "pgmwindres"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_windres = f }-  , make_ord_flag defFlag "pgmlibtool"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_libtool = f }-  , make_ord_flag defFlag "pgmar"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_ar = f }-  , make_ord_flag defFlag "pgmranlib"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_pgm_ranlib = f }---    -- need to appear before -optl/-opta to be parsed as LLVM flags.-  , make_ord_flag defFlag "optlo"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_lo  = f : toolSettings_opt_lo s }-  , make_ord_flag defFlag "optlc"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_lc  = f : toolSettings_opt_lc s }-  , make_ord_flag defFlag "opti"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_i   = f : toolSettings_opt_i s }-  , make_ord_flag defFlag "optL"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_L   = f : toolSettings_opt_L s }-  , make_ord_flag defFlag "optP"-      (hasArg addOptP)-  , make_ord_flag defFlag "optF"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_F   = f : toolSettings_opt_F s }-  , make_ord_flag defFlag "optc"-      (hasArg addOptc)-  , make_ord_flag defFlag "optcxx"-      (hasArg addOptcxx)-  , make_ord_flag defFlag "opta"-      $ hasArg $ \f -> alterToolSettings $ \s -> s { toolSettings_opt_a   = f : toolSettings_opt_a s }-  , make_ord_flag defFlag "optl"-      (hasArg addOptl)-  , make_ord_flag defFlag "optwindres"-      $ hasArg $ \f ->-        alterToolSettings $ \s -> s { toolSettings_opt_windres = f : toolSettings_opt_windres s }--  , make_ord_flag defGhcFlag "split-objs"-      (NoArg $ addWarn "ignoring -split-objs")--  , make_ord_flag defGhcFlag "split-sections"-      (noArgM (\dflags -> do-        if platformHasSubsectionsViaSymbols (targetPlatform dflags)-          then do addWarn $-                    "-split-sections is not useful on this platform " ++-                    "since it always uses subsections via symbols. Ignoring."-                  return dflags-          else return (gopt_set dflags Opt_SplitSections)))--        -------- ghc -M ------------------------------------------------------  , make_ord_flag defGhcFlag "dep-suffix"              (hasArg addDepSuffix)-  , make_ord_flag defGhcFlag "dep-makefile"            (hasArg setDepMakefile)-  , make_ord_flag defGhcFlag "include-cpp-deps"-        (noArg (setDepIncludeCppDeps True))-  , make_ord_flag defGhcFlag "include-pkg-deps"-        (noArg (setDepIncludePkgDeps True))-  , make_ord_flag defGhcFlag "exclude-module"          (hasArg addDepExcludeMod)--        -------- Linking -----------------------------------------------------  , make_ord_flag defGhcFlag "no-link"-        (noArg (\d -> d { ghcLink=NoLink }))-  , make_ord_flag defGhcFlag "shared"-        (noArg (\d -> d { ghcLink=LinkDynLib }))-  , make_ord_flag defGhcFlag "staticlib"-        (noArg (\d -> d { ghcLink=LinkStaticLib }))-  , make_ord_flag defGhcFlag "dynload"            (hasArg parseDynLibLoaderMode)-  , make_ord_flag defGhcFlag "dylib-install-name" (hasArg setDylibInstallName)--        ------- Libraries ----------------------------------------------------  , make_ord_flag defFlag "L"   (Prefix addLibraryPath)-  , make_ord_flag defFlag "l"   (hasArg (addLdInputs . Option . ("-l" ++)))--        ------- Frameworks ---------------------------------------------------        -- -framework-path should really be -F ...-  , make_ord_flag defFlag "framework-path" (HasArg addFrameworkPath)-  , make_ord_flag defFlag "framework"      (hasArg addCmdlineFramework)--        ------- Output Redirection -------------------------------------------  , make_ord_flag defGhcFlag "odir"              (hasArg setObjectDir)-  , make_ord_flag defGhcFlag "o"                 (sepArg (setOutputFile . Just))-  , make_ord_flag defGhcFlag "dyno"-        (sepArg (setDynOutputFile . Just))-  , make_ord_flag defGhcFlag "ohi"-        (hasArg (setOutputHi . Just ))-  , make_ord_flag defGhcFlag "osuf"              (hasArg setObjectSuf)-  , make_ord_flag defGhcFlag "dynosuf"           (hasArg setDynObjectSuf)-  , make_ord_flag defGhcFlag "hcsuf"             (hasArg setHcSuf)-  , make_ord_flag defGhcFlag "hisuf"             (hasArg setHiSuf)-  , make_ord_flag defGhcFlag "hiesuf"            (hasArg setHieSuf)-  , make_ord_flag defGhcFlag "dynhisuf"          (hasArg setDynHiSuf)-  , make_ord_flag defGhcFlag "hidir"             (hasArg setHiDir)-  , make_ord_flag defGhcFlag "hiedir"            (hasArg setHieDir)-  , make_ord_flag defGhcFlag "tmpdir"            (hasArg setTmpDir)-  , make_ord_flag defGhcFlag "stubdir"           (hasArg setStubDir)-  , make_ord_flag defGhcFlag "dumpdir"           (hasArg setDumpDir)-  , make_ord_flag defGhcFlag "outputdir"         (hasArg setOutputDir)-  , make_ord_flag defGhcFlag "ddump-file-prefix"-        (hasArg (setDumpPrefixForce . Just))--  , make_ord_flag defGhcFlag "dynamic-too"-        (NoArg (setGeneralFlag Opt_BuildDynamicToo))--        ------- Keeping temporary files --------------------------------------     -- These can be singular (think ghc -c) or plural (think ghc --make)-  , make_ord_flag defGhcFlag "keep-hc-file"-        (NoArg (setGeneralFlag Opt_KeepHcFiles))-  , make_ord_flag defGhcFlag "keep-hc-files"-        (NoArg (setGeneralFlag Opt_KeepHcFiles))-  , make_ord_flag defGhcFlag "keep-hscpp-file"-        (NoArg (setGeneralFlag Opt_KeepHscppFiles))-  , make_ord_flag defGhcFlag "keep-hscpp-files"-        (NoArg (setGeneralFlag Opt_KeepHscppFiles))-  , make_ord_flag defGhcFlag "keep-s-file"-        (NoArg (setGeneralFlag Opt_KeepSFiles))-  , make_ord_flag defGhcFlag "keep-s-files"-        (NoArg (setGeneralFlag Opt_KeepSFiles))-  , make_ord_flag defGhcFlag "keep-llvm-file"-        (NoArg $ setObjTarget HscLlvm >> setGeneralFlag Opt_KeepLlvmFiles)-  , make_ord_flag defGhcFlag "keep-llvm-files"-        (NoArg $ setObjTarget HscLlvm >> setGeneralFlag Opt_KeepLlvmFiles)-     -- This only makes sense as plural-  , make_ord_flag defGhcFlag "keep-tmp-files"-        (NoArg (setGeneralFlag Opt_KeepTmpFiles))-  , make_ord_flag defGhcFlag "keep-hi-file"-        (NoArg (setGeneralFlag Opt_KeepHiFiles))-  , make_ord_flag defGhcFlag "no-keep-hi-file"-        (NoArg (unSetGeneralFlag Opt_KeepHiFiles))-  , make_ord_flag defGhcFlag "keep-hi-files"-        (NoArg (setGeneralFlag Opt_KeepHiFiles))-  , make_ord_flag defGhcFlag "no-keep-hi-files"-        (NoArg (unSetGeneralFlag Opt_KeepHiFiles))-  , make_ord_flag defGhcFlag "keep-o-file"-        (NoArg (setGeneralFlag Opt_KeepOFiles))-  , make_ord_flag defGhcFlag "no-keep-o-file"-        (NoArg (unSetGeneralFlag Opt_KeepOFiles))-  , make_ord_flag defGhcFlag "keep-o-files"-        (NoArg (setGeneralFlag Opt_KeepOFiles))-  , make_ord_flag defGhcFlag "no-keep-o-files"-        (NoArg (unSetGeneralFlag Opt_KeepOFiles))--        ------- Miscellaneous -----------------------------------------------  , make_ord_flag defGhcFlag "no-auto-link-packages"-        (NoArg (unSetGeneralFlag Opt_AutoLinkPackages))-  , make_ord_flag defGhcFlag "no-hs-main"-        (NoArg (setGeneralFlag Opt_NoHsMain))-  , make_ord_flag defGhcFlag "fno-state-hack"-        (NoArg (setGeneralFlag Opt_G_NoStateHack))-  , make_ord_flag defGhcFlag "fno-opt-coercion"-        (NoArg (setGeneralFlag Opt_G_NoOptCoercion))-  , make_ord_flag defGhcFlag "with-rtsopts"-        (HasArg setRtsOpts)-  , make_ord_flag defGhcFlag "rtsopts"-        (NoArg (setRtsOptsEnabled RtsOptsAll))-  , make_ord_flag defGhcFlag "rtsopts=all"-        (NoArg (setRtsOptsEnabled RtsOptsAll))-  , make_ord_flag defGhcFlag "rtsopts=some"-        (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 "dhex-word-literals"-        (NoArg (setGeneralFlag Opt_HexWordLiterals))--  , 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)-  , make_ord_flag defGhcFlag "hpcdir"               (SepArg setOptHpcDir)-  , make_ord_flag defGhciFlag "ghci-script"         (hasArg addGhciScript)-  , make_ord_flag defGhciFlag "interactive-print"   (hasArg setInteractivePrint)-  , make_ord_flag defGhcFlag "ticky-allocd"-        (NoArg (setGeneralFlag Opt_Ticky_Allocd))-  , make_ord_flag defGhcFlag "ticky-LNE"-        (NoArg (setGeneralFlag Opt_Ticky_LNE))-  , make_ord_flag defGhcFlag "ticky-dyn-thunk"-        (NoArg (setGeneralFlag Opt_Ticky_Dyn_Thunk))-        ------- recompilation checker ---------------------------------------  , make_dep_flag defGhcFlag "recomp"-        (NoArg $ unSetGeneralFlag Opt_ForceRecomp)-             "Use -fno-force-recomp instead"-  , make_dep_flag defGhcFlag "no-recomp"-        (NoArg $ setGeneralFlag Opt_ForceRecomp) "Use -fforce-recomp instead"-  , make_ord_flag defFlag "fmax-errors"-      (intSuffix (\n d -> d { maxErrors = Just (max 1 n) }))-  , make_ord_flag defFlag "fno-max-errors"-      (noArg (\d -> d { maxErrors = Nothing }))-  , make_ord_flag defFlag "freverse-errors"-        (noArg (\d -> d {reverseErrors = True} ))-  , make_ord_flag defFlag "fno-reverse-errors"-        (noArg (\d -> d {reverseErrors = False} ))--        ------ HsCpp opts ----------------------------------------------------  , make_ord_flag defFlag "D"              (AnySuffix (upd . addOptP))-  , make_ord_flag defFlag "U"              (AnySuffix (upd . addOptP))--        ------- Include/Import Paths -----------------------------------------  , make_ord_flag defFlag "I"              (Prefix    addIncludePath)-  , make_ord_flag defFlag "i"              (OptPrefix addImportPath)--        ------ Output style options ------------------------------------------  , make_ord_flag defFlag "dppr-user-length" (intSuffix (\n d ->-                                                       d { pprUserLength = n }))-  , make_ord_flag defFlag "dppr-cols"        (intSuffix (\n d ->-                                                             d { pprCols = n }))-  , make_ord_flag defFlag "fdiagnostics-color=auto"-      (NoArg (upd (\d -> d { useColor = Auto })))-  , make_ord_flag defFlag "fdiagnostics-color=always"-      (NoArg (upd (\d -> d { useColor = Always })))-  , make_ord_flag defFlag "fdiagnostics-color=never"-      (NoArg (upd (\d -> d { useColor = Never })))--  -- Suppress all that is suppressable in core dumps.-  -- Except for uniques, as some simplifier phases introduce new variables that-  -- have otherwise identical names.-  , make_ord_flag defGhcFlag "dsuppress-all"-      (NoArg $ do setGeneralFlag Opt_SuppressCoercions-                  setGeneralFlag Opt_SuppressVarKinds-                  setGeneralFlag Opt_SuppressModulePrefixes-                  setGeneralFlag Opt_SuppressTypeApplications-                  setGeneralFlag Opt_SuppressIdInfo-                  setGeneralFlag Opt_SuppressTicks-                  setGeneralFlag Opt_SuppressStgExts-                  setGeneralFlag Opt_SuppressTypeSignatures-                  setGeneralFlag Opt_SuppressTimestamps)--        ------ Debugging -----------------------------------------------------  , make_ord_flag defGhcFlag "dstg-stats"-        (NoArg (setGeneralFlag Opt_StgStats))--  , make_ord_flag defGhcFlag "ddump-cmm"-        (setDumpFlag Opt_D_dump_cmm)-  , make_ord_flag defGhcFlag "ddump-cmm-from-stg"-        (setDumpFlag Opt_D_dump_cmm_from_stg)-  , make_ord_flag defGhcFlag "ddump-cmm-raw"-        (setDumpFlag Opt_D_dump_cmm_raw)-  , make_ord_flag defGhcFlag "ddump-cmm-verbose"-        (setDumpFlag Opt_D_dump_cmm_verbose)-  , make_ord_flag defGhcFlag "ddump-cmm-verbose-by-proc"-        (setDumpFlag Opt_D_dump_cmm_verbose_by_proc)-  , make_ord_flag defGhcFlag "ddump-cmm-cfg"-        (setDumpFlag Opt_D_dump_cmm_cfg)-  , make_ord_flag defGhcFlag "ddump-cmm-cbe"-        (setDumpFlag Opt_D_dump_cmm_cbe)-  , make_ord_flag defGhcFlag "ddump-cmm-switch"-        (setDumpFlag Opt_D_dump_cmm_switch)-  , make_ord_flag defGhcFlag "ddump-cmm-proc"-        (setDumpFlag Opt_D_dump_cmm_proc)-  , make_ord_flag defGhcFlag "ddump-cmm-sp"-        (setDumpFlag Opt_D_dump_cmm_sp)-  , make_ord_flag defGhcFlag "ddump-cmm-sink"-        (setDumpFlag Opt_D_dump_cmm_sink)-  , make_ord_flag defGhcFlag "ddump-cmm-caf"-        (setDumpFlag Opt_D_dump_cmm_caf)-  , make_ord_flag defGhcFlag "ddump-cmm-procmap"-        (setDumpFlag Opt_D_dump_cmm_procmap)-  , make_ord_flag defGhcFlag "ddump-cmm-split"-        (setDumpFlag Opt_D_dump_cmm_split)-  , make_ord_flag defGhcFlag "ddump-cmm-info"-        (setDumpFlag Opt_D_dump_cmm_info)-  , make_ord_flag defGhcFlag "ddump-cmm-cps"-        (setDumpFlag Opt_D_dump_cmm_cps)-  , make_ord_flag defGhcFlag "ddump-cfg-weights"-        (setDumpFlag Opt_D_dump_cfg_weights)-  , make_ord_flag defGhcFlag "ddump-core-stats"-        (setDumpFlag Opt_D_dump_core_stats)-  , make_ord_flag defGhcFlag "ddump-asm"-        (setDumpFlag Opt_D_dump_asm)-  , make_ord_flag defGhcFlag "ddump-asm-native"-        (setDumpFlag Opt_D_dump_asm_native)-  , make_ord_flag defGhcFlag "ddump-asm-liveness"-        (setDumpFlag Opt_D_dump_asm_liveness)-  , make_ord_flag defGhcFlag "ddump-asm-regalloc"-        (setDumpFlag Opt_D_dump_asm_regalloc)-  , make_ord_flag defGhcFlag "ddump-asm-conflicts"-        (setDumpFlag Opt_D_dump_asm_conflicts)-  , make_ord_flag defGhcFlag "ddump-asm-regalloc-stages"-        (setDumpFlag Opt_D_dump_asm_regalloc_stages)-  , make_ord_flag defGhcFlag "ddump-asm-stats"-        (setDumpFlag Opt_D_dump_asm_stats)-  , make_ord_flag defGhcFlag "ddump-asm-expanded"-        (setDumpFlag Opt_D_dump_asm_expanded)-  , make_ord_flag defGhcFlag "ddump-llvm"-        (NoArg $ setObjTarget HscLlvm >> setDumpFlag' Opt_D_dump_llvm)-  , make_ord_flag defGhcFlag "ddump-deriv"-        (setDumpFlag Opt_D_dump_deriv)-  , make_ord_flag defGhcFlag "ddump-ds"-        (setDumpFlag Opt_D_dump_ds)-  , make_ord_flag defGhcFlag "ddump-ds-preopt"-        (setDumpFlag Opt_D_dump_ds_preopt)-  , make_ord_flag defGhcFlag "ddump-foreign"-        (setDumpFlag Opt_D_dump_foreign)-  , make_ord_flag defGhcFlag "ddump-inlinings"-        (setDumpFlag Opt_D_dump_inlinings)-  , make_ord_flag defGhcFlag "ddump-rule-firings"-        (setDumpFlag Opt_D_dump_rule_firings)-  , make_ord_flag defGhcFlag "ddump-rule-rewrites"-        (setDumpFlag Opt_D_dump_rule_rewrites)-  , make_ord_flag defGhcFlag "ddump-simpl-trace"-        (setDumpFlag Opt_D_dump_simpl_trace)-  , make_ord_flag defGhcFlag "ddump-occur-anal"-        (setDumpFlag Opt_D_dump_occur_anal)-  , make_ord_flag defGhcFlag "ddump-parsed"-        (setDumpFlag Opt_D_dump_parsed)-  , make_ord_flag defGhcFlag "ddump-parsed-ast"-        (setDumpFlag Opt_D_dump_parsed_ast)-  , make_ord_flag defGhcFlag "ddump-rn"-        (setDumpFlag Opt_D_dump_rn)-  , make_ord_flag defGhcFlag "ddump-rn-ast"-        (setDumpFlag Opt_D_dump_rn_ast)-  , make_ord_flag defGhcFlag "ddump-simpl"-        (setDumpFlag Opt_D_dump_simpl)-  , make_ord_flag defGhcFlag "ddump-simpl-iterations"-      (setDumpFlag Opt_D_dump_simpl_iterations)-  , make_ord_flag defGhcFlag "ddump-spec"-        (setDumpFlag Opt_D_dump_spec)-  , make_ord_flag defGhcFlag "ddump-prep"-        (setDumpFlag Opt_D_dump_prep)-  , make_ord_flag defGhcFlag "ddump-stg"-        (setDumpFlag Opt_D_dump_stg)-  , make_ord_flag defGhcFlag "ddump-stg-unarised"-        (setDumpFlag Opt_D_dump_stg_unarised)-  , make_ord_flag defGhcFlag "ddump-stg-final"-        (setDumpFlag Opt_D_dump_stg_final)-  , 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"-        (setDumpFlag Opt_D_dump_str_signatures)-  , make_ord_flag defGhcFlag "ddump-tc"-        (setDumpFlag Opt_D_dump_tc)-  , make_ord_flag defGhcFlag "ddump-tc-ast"-        (setDumpFlag Opt_D_dump_tc_ast)-  , make_ord_flag defGhcFlag "ddump-types"-        (setDumpFlag Opt_D_dump_types)-  , make_ord_flag defGhcFlag "ddump-rules"-        (setDumpFlag Opt_D_dump_rules)-  , make_ord_flag defGhcFlag "ddump-cse"-        (setDumpFlag Opt_D_dump_cse)-  , make_ord_flag defGhcFlag "ddump-worker-wrapper"-        (setDumpFlag Opt_D_dump_worker_wrapper)-  , make_ord_flag defGhcFlag "ddump-rn-trace"-        (setDumpFlag Opt_D_dump_rn_trace)-  , make_ord_flag defGhcFlag "ddump-if-trace"-        (setDumpFlag Opt_D_dump_if_trace)-  , make_ord_flag defGhcFlag "ddump-cs-trace"-        (setDumpFlag Opt_D_dump_cs_trace)-  , make_ord_flag defGhcFlag "ddump-tc-trace"-        (NoArg (do setDumpFlag' Opt_D_dump_tc_trace-                   setDumpFlag' Opt_D_dump_cs_trace))-  , make_ord_flag defGhcFlag "ddump-ec-trace"-        (setDumpFlag Opt_D_dump_ec_trace)-  , make_ord_flag defGhcFlag "ddump-vt-trace"-        (setDumpFlag Opt_D_dump_vt_trace)-  , make_ord_flag defGhcFlag "ddump-splices"-        (setDumpFlag Opt_D_dump_splices)-  , make_ord_flag defGhcFlag "dth-dec-file"-        (setDumpFlag Opt_D_th_dec_file)--  , make_ord_flag defGhcFlag "ddump-rn-stats"-        (setDumpFlag Opt_D_dump_rn_stats)-  , make_ord_flag defGhcFlag "ddump-opt-cmm"-        (setDumpFlag Opt_D_dump_opt_cmm)-  , make_ord_flag defGhcFlag "ddump-simpl-stats"-        (setDumpFlag Opt_D_dump_simpl_stats)-  , make_ord_flag defGhcFlag "ddump-bcos"-        (setDumpFlag Opt_D_dump_BCOs)-  , make_ord_flag defGhcFlag "dsource-stats"-        (setDumpFlag Opt_D_source_stats)-  , make_ord_flag defGhcFlag "dverbose-core2core"-        (NoArg $ setVerbosity (Just 2) >> setVerboseCore2Core)-  , make_ord_flag defGhcFlag "dverbose-stg2stg"-        (setDumpFlag Opt_D_verbose_stg2stg)-  , make_ord_flag defGhcFlag "ddump-hi"-        (setDumpFlag Opt_D_dump_hi)-  , make_ord_flag defGhcFlag "ddump-minimal-imports"-        (NoArg (setGeneralFlag Opt_D_dump_minimal_imports))-  , make_ord_flag defGhcFlag "ddump-hpc"-        (setDumpFlag Opt_D_dump_ticked) -- back compat-  , make_ord_flag defGhcFlag "ddump-ticked"-        (setDumpFlag Opt_D_dump_ticked)-  , make_ord_flag defGhcFlag "ddump-mod-cycles"-        (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"-        (NoArg (setGeneralFlag Opt_DumpToFile))-  , make_ord_flag defGhcFlag "ddump-hi-diffs"-        (setDumpFlag Opt_D_dump_hi_diffs)-  , make_ord_flag defGhcFlag "ddump-rtti"-        (setDumpFlag Opt_D_dump_rtti)-  , make_ord_flag defGhcFlag "dcore-lint"-        (NoArg (setGeneralFlag Opt_DoCoreLinting))-  , make_ord_flag defGhcFlag "dstg-lint"-        (NoArg (setGeneralFlag Opt_DoStgLinting))-  , make_ord_flag defGhcFlag "dcmm-lint"-        (NoArg (setGeneralFlag Opt_DoCmmLinting))-  , make_ord_flag defGhcFlag "dasm-lint"-        (NoArg (setGeneralFlag Opt_DoAsmLinting))-  , make_ord_flag defGhcFlag "dannot-lint"-        (NoArg (setGeneralFlag Opt_DoAnnotationLinting))-  , make_ord_flag defGhcFlag "dshow-passes"-        (NoArg $ forceRecompile >> (setVerbosity $ Just 2))-  , make_ord_flag defGhcFlag "dfaststring-stats"-        (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 "dno-typeable-binds"-        (NoArg (setGeneralFlag Opt_NoTypeableBinds))-  , 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)--        ------ Machine dependent (-m<blah>) stuff -----------------------------  , make_ord_flag defGhcFlag "msse"         (noArg (\d ->-                                                  d { sseVersion = Just SSE1 }))-  , make_ord_flag defGhcFlag "msse2"        (noArg (\d ->-                                                  d { sseVersion = Just SSE2 }))-  , make_ord_flag defGhcFlag "msse3"        (noArg (\d ->-                                                  d { sseVersion = Just SSE3 }))-  , make_ord_flag defGhcFlag "msse4"        (noArg (\d ->-                                                  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 ->-                                                         d { avx512cd = True }))-  , make_ord_flag defGhcFlag "mavx512er"    (noArg (\d ->-                                                         d { avx512er = True }))-  , make_ord_flag defGhcFlag "mavx512f"     (noArg (\d -> d { avx512f = True }))-  , make_ord_flag defGhcFlag "mavx512pf"    (noArg (\d ->-                                                         d { avx512pf = True }))--     ------ Warning opts --------------------------------------------------  , make_ord_flag defFlag "W"       (NoArg (mapM_ setWarningFlag minusWOpts))-  , make_ord_flag defFlag "Werror"-               (NoArg (do { setGeneralFlag Opt_WarnIsError-                          ; mapM_ setFatalWarningFlag minusWeverythingOpts   }))-  , make_ord_flag defFlag "Wwarn"-               (NoArg (do { unSetGeneralFlag Opt_WarnIsError-                          ; mapM_ unSetFatalWarningFlag minusWeverythingOpts }))-                          -- Opt_WarnIsError is still needed to pass -Werror-                          -- to CPP; see runCpp in SysTools-  , make_dep_flag defFlag "Wnot"    (NoArg (upd (\d ->-                                              d {warningFlags = EnumSet.empty})))-                                             "Use -w or -Wno-everything instead"-  , make_ord_flag defFlag "w"       (NoArg (upd (\d ->-                                              d {warningFlags = EnumSet.empty})))--     -- New-style uniform warning sets-     ---     -- Note that -Weverything > -Wall > -Wextra > -Wdefault > -Wno-everything-  , make_ord_flag defFlag "Weverything"    (NoArg (mapM_-                                           setWarningFlag minusWeverythingOpts))-  , make_ord_flag defFlag "Wno-everything"-                           (NoArg (upd (\d -> d {warningFlags = EnumSet.empty})))--  , make_ord_flag defFlag "Wall"           (NoArg (mapM_-                                                  setWarningFlag minusWallOpts))-  , make_ord_flag defFlag "Wno-all"        (NoArg (mapM_-                                                unSetWarningFlag minusWallOpts))--  , make_ord_flag defFlag "Wextra"         (NoArg (mapM_-                                                     setWarningFlag minusWOpts))-  , make_ord_flag defFlag "Wno-extra"      (NoArg (mapM_-                                                   unSetWarningFlag minusWOpts))--  , make_ord_flag defFlag "Wdefault"       (NoArg (mapM_-                                               setWarningFlag standardWarnings))-  , make_ord_flag defFlag "Wno-default"    (NoArg (mapM_-                                             unSetWarningFlag standardWarnings))--  , make_ord_flag defFlag "Wcompat"        (NoArg (mapM_-                                               setWarningFlag minusWcompatOpts))-  , make_ord_flag defFlag "Wno-compat"     (NoArg (mapM_-                                             unSetWarningFlag minusWcompatOpts))--        ------ Plugin flags -------------------------------------------------  , make_ord_flag defGhcFlag "fplugin-opt" (hasArg addPluginModuleNameOption)-  , make_ord_flag defGhcFlag "fplugin-trustworthy"-      (NoArg (setGeneralFlag Opt_PluginTrustworthy))-  , make_ord_flag defGhcFlag "fplugin"     (hasArg addPluginModuleName)-  , make_ord_flag defGhcFlag "fclear-plugins" (noArg clearPluginModuleNames)-  , make_ord_flag defGhcFlag "ffrontend-opt" (hasArg addFrontendPluginOption)--        ------ Optimisation flags -------------------------------------------  , make_dep_flag defGhcFlag "Onot"   (noArgM $ setOptLevel 0 )-                                                            "Use -O0 instead"-  , make_ord_flag defGhcFlag "O"      (optIntSuffixM (\mb_n ->-                                                setOptLevel (mb_n `orElse` 1)))-                -- If the number is missing, use 1--  , make_ord_flag defFlag "fbinary-blob-threshold"-      (intSuffix (\n d -> d { binBlobThreshold = fromIntegral n }))--  , make_ord_flag defFlag "fmax-relevant-binds"-      (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-hole-fits"-      (intSuffix (\n d -> d { maxValidHoleFits = Just n }))-  , make_ord_flag defFlag "fno-max-valid-hole-fits"-      (noArg (\d -> d { maxValidHoleFits = Nothing }))-  , make_ord_flag defFlag "fmax-refinement-hole-fits"-      (intSuffix (\n d -> d { maxRefHoleFits = Just n }))-  , make_ord_flag defFlag "fno-max-refinement-hole-fits"-      (noArg (\d -> d { maxRefHoleFits = Nothing }))-  , make_ord_flag defFlag "frefinement-level-hole-fits"-      (intSuffix (\n d -> d { refLevelHoleFits = Just n }))-  , make_ord_flag defFlag "fno-refinement-level-hole-fits"-      (noArg (\d -> d { refLevelHoleFits = Nothing }))--  , make_dep_flag defGhcFlag "fllvm-pass-vectors-in-regs"-            (noArg id)-            "vectors registers are now passed in registers by default."-  , make_ord_flag defFlag "fmax-uncovered-patterns"-      (intSuffix (\n d -> d { maxUncoveredPatterns = n }))-  , make_ord_flag defFlag "fmax-pmcheck-models"-      (intSuffix (\n d -> d { maxPmCheckModels = n }))-  , make_ord_flag defFlag "fsimplifier-phases"-      (intSuffix (\n d -> d { simplPhases = n }))-  , make_ord_flag defFlag "fmax-simplifier-iterations"-      (intSuffix (\n d -> d { maxSimplIterations = n }))-  , (Deprecated, defFlag "fmax-pmcheck-iterations"-      (intSuffixM (\_ d ->-       do { deprecate $ "use -fmax-pmcheck-models instead"-          ; return d })))-  , make_ord_flag defFlag "fsimpl-tick-factor"-      (intSuffix (\n d -> d { simplTickFactor = n }))-  , make_ord_flag defFlag "fspec-constr-threshold"-      (intSuffix (\n d -> d { specConstrThreshold = Just n }))-  , make_ord_flag defFlag "fno-spec-constr-threshold"-      (noArg (\d -> d { specConstrThreshold = Nothing }))-  , make_ord_flag defFlag "fspec-constr-count"-      (intSuffix (\n d -> d { specConstrCount = Just n }))-  , make_ord_flag defFlag "fno-spec-constr-count"-      (noArg (\d -> d { specConstrCount = Nothing }))-  , make_ord_flag defFlag "fspec-constr-recursive"-      (intSuffix (\n d -> d { specConstrRecursive = n }))-  , make_ord_flag defFlag "fliberate-case-threshold"-      (intSuffix (\n d -> d { liberateCaseThreshold = Just n }))-  , make_ord_flag defFlag "fno-liberate-case-threshold"-      (noArg (\d -> d { liberateCaseThreshold = Nothing }))-  , make_ord_flag defFlag "drule-check"-      (sepArg (\s d -> d { ruleCheck = Just s }))-  , make_ord_flag defFlag "dinline-check"-      (sepArg (\s d -> d { inlineCheck = Just s }))-  , make_ord_flag defFlag "freduction-depth"-      (intSuffix (\n d -> d { reductionDepth = treatZeroAsInf n }))-  , make_ord_flag defFlag "fconstraint-solver-iterations"-      (intSuffix (\n d -> d { solverIterations = treatZeroAsInf n }))-  , (Deprecated, defFlag "fcontext-stack"-      (intSuffixM (\n d ->-       do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"-          ; return $ d { reductionDepth = treatZeroAsInf n } })))-  , (Deprecated, defFlag "ftype-function-depth"-      (intSuffixM (\n d ->-       do { deprecate $ "use -freduction-depth=" ++ show n ++ " instead"-          ; return $ d { reductionDepth = treatZeroAsInf n } })))-  , make_ord_flag defFlag "fstrictness-before"-      (intSuffix (\n d -> d { strictnessBefore = n : strictnessBefore d }))-  , make_ord_flag defFlag "ffloat-lam-args"-      (intSuffix (\n d -> d { floatLamArgs = Just n }))-  , make_ord_flag defFlag "ffloat-all-lams"-      (noArg (\d -> d { floatLamArgs = Nothing }))-  , make_ord_flag defFlag "fstg-lift-lams-rec-args"-      (intSuffix (\n d -> d { liftLamsRecArgs = Just n }))-  , make_ord_flag defFlag "fstg-lift-lams-rec-args-any"-      (noArg (\d -> d { liftLamsRecArgs = Nothing }))-  , make_ord_flag defFlag "fstg-lift-lams-non-rec-args"-      (intSuffix (\n d -> d { liftLamsRecArgs = Just n }))-  , make_ord_flag defFlag "fstg-lift-lams-non-rec-args-any"-      (noArg (\d -> d { liftLamsRecArgs = Nothing }))-  , make_ord_flag defFlag "fstg-lift-lams-known"-      (noArg (\d -> d { liftLamsKnown = True }))-  , make_ord_flag defFlag "fno-stg-lift-lams-known"-      (noArg (\d -> d { liftLamsKnown = False }))-  , make_ord_flag defFlag "fproc-alignment"-      (intSuffix (\n d -> d { cmmProcAlignment = Just n }))-  , make_ord_flag defFlag "fblock-layout-weights"-        (HasArg (\s ->-            upd (\d -> d { cfgWeightInfo =-                parseCfgWeights s (cfgWeightInfo d)})))-  , make_ord_flag defFlag "fhistory-size"-      (intSuffix (\n d -> d { historySize = n }))-  , make_ord_flag defFlag "funfolding-creation-threshold"-      (intSuffix   (\n d -> d {ufCreationThreshold = n}))-  , make_ord_flag defFlag "funfolding-use-threshold"-      (intSuffix   (\n d -> d {ufUseThreshold = n}))-  , make_ord_flag defFlag "funfolding-fun-discount"-      (intSuffix   (\n d -> d {ufFunAppDiscount = n}))-  , make_ord_flag defFlag "funfolding-dict-discount"-      (intSuffix   (\n d -> d {ufDictDiscount = n}))-  , make_ord_flag defFlag "funfolding-keeness-factor"-      (floatSuffix (\n d -> d {ufKeenessFactor = n}))-  , make_ord_flag defFlag "fmax-worker-args"-      (intSuffix (\n d -> d {maxWorkerArgs = n}))-  , make_ord_flag defGhciFlag "fghci-hist-size"-      (intSuffix (\n d -> d {ghciHistSize = n}))-  , make_ord_flag defGhcFlag "fmax-inline-alloc-size"-      (intSuffix (\n d -> d { maxInlineAllocSize = n }))-  , make_ord_flag defGhcFlag "fmax-inline-memcpy-insns"-      (intSuffix (\n d -> d { maxInlineMemcpyInsns = n }))-  , make_ord_flag defGhcFlag "fmax-inline-memset-insns"-      (intSuffix (\n d -> d { maxInlineMemsetInsns = n }))-  , make_ord_flag defGhcFlag "dinitial-unique"-      (intSuffix (\n d -> d { initialUnique = n }))-  , make_ord_flag defGhcFlag "dunique-increment"-      (intSuffix (\n d -> d { uniqueIncrement = n }))--        ------ Profiling ------------------------------------------------------        -- OLD profiling flags-  , make_dep_flag defGhcFlag "auto-all"-                    (noArg (\d -> d { profAuto = ProfAutoAll } ))-                    "Use -fprof-auto instead"-  , make_dep_flag defGhcFlag "no-auto-all"-                    (noArg (\d -> d { profAuto = NoProfAuto } ))-                    "Use -fno-prof-auto instead"-  , make_dep_flag defGhcFlag "auto"-                    (noArg (\d -> d { profAuto = ProfAutoExports } ))-                    "Use -fprof-auto-exported instead"-  , make_dep_flag defGhcFlag "no-auto"-            (noArg (\d -> d { profAuto = NoProfAuto } ))-                    "Use -fno-prof-auto instead"-  , make_dep_flag defGhcFlag "caf-all"-            (NoArg (setGeneralFlag Opt_AutoSccsOnIndividualCafs))-                    "Use -fprof-cafs instead"-  , make_dep_flag defGhcFlag "no-caf-all"-            (NoArg (unSetGeneralFlag Opt_AutoSccsOnIndividualCafs))-                    "Use -fno-prof-cafs instead"--        -- NEW profiling flags-  , make_ord_flag defGhcFlag "fprof-auto"-      (noArg (\d -> d { profAuto = ProfAutoAll } ))-  , make_ord_flag defGhcFlag "fprof-auto-top"-      (noArg (\d -> d { profAuto = ProfAutoTop } ))-  , make_ord_flag defGhcFlag "fprof-auto-exported"-      (noArg (\d -> d { profAuto = ProfAutoExports } ))-  , make_ord_flag defGhcFlag "fprof-auto-calls"-      (noArg (\d -> d { profAuto = ProfAutoCalls } ))-  , make_ord_flag defGhcFlag "fno-prof-auto"-      (noArg (\d -> d { profAuto = NoProfAuto } ))--        ------ Compiler flags -------------------------------------------------  , make_ord_flag defGhcFlag "fasm"             (NoArg (setObjTarget HscAsm))-  , make_ord_flag defGhcFlag "fvia-c"           (NoArg-         (deprecate $ "The -fvia-c flag does nothing; " ++-                      "it will be removed in a future GHC release"))-  , make_ord_flag defGhcFlag "fvia-C"           (NoArg-         (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 ->-                  d { ghcLink=NoLink }) >> setTarget HscNothing))-  , make_ord_flag defFlag "fbyte-code"-      (noArgM $ \dflags -> do-        setTarget HscInterpreted-        pure $ gopt_set dflags Opt_ByteCode)-  , make_ord_flag defFlag "fobject-code"     $ NoArg $ do-      dflags <- liftEwM getCmdLineState-      setTarget $ defaultObjectTarget dflags--  , make_dep_flag defFlag "fglasgow-exts"-      (NoArg enableGlasgowExts) "Use individual extensions instead"-  , make_dep_flag defFlag "fno-glasgow-exts"-      (NoArg disableGlasgowExts) "Use individual extensions instead"-  , make_ord_flag defFlag "Wunused-binds" (NoArg enableUnusedBinds)-  , make_ord_flag defFlag "Wno-unused-binds" (NoArg disableUnusedBinds)-  , make_ord_flag defHiddenFlag "fwarn-unused-binds" (NoArg enableUnusedBinds)-  , make_ord_flag defHiddenFlag "fno-warn-unused-binds" (NoArg-                                                            disableUnusedBinds)--        ------ Safe Haskell flags --------------------------------------------  , make_ord_flag defFlag "fpackage-trust"   (NoArg setPackageTrust)-  , make_ord_flag defFlag "fno-safe-infer"   (noArg (\d ->-                                                    d { safeInfer = False }))-  , make_ord_flag defFlag "fno-safe-haskell" (NoArg (setSafeHaskell Sf_Ignore))--        ------ position independent flags  -----------------------------------  , make_ord_flag defGhcFlag "fPIC"          (NoArg (setGeneralFlag Opt_PIC))-  , make_ord_flag defGhcFlag "fno-PIC"       (NoArg (unSetGeneralFlag Opt_PIC))-  , make_ord_flag defGhcFlag "fPIE"          (NoArg (setGeneralFlag Opt_PIC))-  , make_ord_flag defGhcFlag "fno-PIE"       (NoArg (unSetGeneralFlag Opt_PIC))--         ------ Debugging flags -----------------------------------------------  , make_ord_flag defGhcFlag "g"             (OptIntSuffix setDebugLevel)- ]- ++ map (mkFlag turnOn  ""          setGeneralFlag    ) negatableFlagsDeps- ++ map (mkFlag turnOff "no-"       unSetGeneralFlag  ) negatableFlagsDeps- ++ map (mkFlag turnOn  "d"         setGeneralFlag    ) dFlagsDeps- ++ map (mkFlag turnOff "dno-"      unSetGeneralFlag  ) dFlagsDeps- ++ map (mkFlag turnOn  "f"         setGeneralFlag    ) fFlagsDeps- ++ map (mkFlag turnOff "fno-"      unSetGeneralFlag  ) fFlagsDeps- ++ map (mkFlag turnOn  "W"         setWarningFlag    ) wWarningFlagsDeps- ++ map (mkFlag turnOff "Wno-"      unSetWarningFlag  ) wWarningFlagsDeps- ++ map (mkFlag turnOn  "Werror="   setWErrorFlag )     wWarningFlagsDeps- ++ map (mkFlag turnOn  "Wwarn="     unSetFatalWarningFlag )-                                                        wWarningFlagsDeps- ++ map (mkFlag turnOn  "Wno-error=" unSetFatalWarningFlag )-                                                        wWarningFlagsDeps- ++ map (mkFlag turnOn  "fwarn-"    setWarningFlag   . hideFlag)-    wWarningFlagsDeps- ++ map (mkFlag turnOff "fno-warn-" unSetWarningFlag . hideFlag)-    wWarningFlagsDeps- ++ [ (NotDeprecated, unrecognisedWarning "W"),-      (Deprecated,    unrecognisedWarning "fwarn-"),-      (Deprecated,    unrecognisedWarning "fno-warn-") ]- ++ [ make_ord_flag defFlag "Werror=compat"-        (NoArg (mapM_ setWErrorFlag minusWcompatOpts))-    , make_ord_flag defFlag "Wno-error=compat"-        (NoArg (mapM_ unSetFatalWarningFlag minusWcompatOpts))-    , make_ord_flag defFlag "Wwarn=compat"-        (NoArg (mapM_ unSetFatalWarningFlag minusWcompatOpts)) ]- ++ map (mkFlag turnOn  "f"         setExtensionFlag  ) fLangFlagsDeps- ++ map (mkFlag turnOff "fno-"      unSetExtensionFlag) fLangFlagsDeps- ++ map (mkFlag turnOn  "X"         setExtensionFlag  ) xFlagsDeps- ++ map (mkFlag turnOff "XNo"       unSetExtensionFlag) xFlagsDeps- ++ map (mkFlag turnOn  "X"         setLanguage       ) languageFlagsDeps- ++ map (mkFlag turnOn  "X"         setSafeHaskell    ) safeHaskellFlagsDeps- ++ [ make_dep_flag defFlag "XGenerics"-        (NoArg $ return ())-                  ("it does nothing; look into -XDefaultSignatures " ++-                   "and -XDeriveGeneric for generic programming support.")-    , make_dep_flag defFlag "XNoGenerics"-        (NoArg $ return ())-               ("it does nothing; look into -XDefaultSignatures and " ++-                  "-XDeriveGeneric for generic programming support.") ]---- | This is where we handle unrecognised warning flags. We only issue a warning--- if -Wunrecognised-warning-flags is set. See #11429 for context.-unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)-unrecognisedWarning prefix = defHiddenFlag prefix (Prefix action)-  where-    action :: String -> EwM (CmdLineP DynFlags) ()-    action flag = do-      f <- wopt Opt_WarnUnrecognisedWarningFlags <$> liftEwM getCmdLineState-      when f $ addFlagWarn Cmd.ReasonUnrecognisedFlag $-        "unrecognised warning flag: -" ++ prefix ++ flag---- See Note [Supporting CLI completion]-package_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]-package_flags_deps = [-        ------- Packages -----------------------------------------------------    make_ord_flag defFlag "package-db"-      (HasArg (addPkgDbRef . PkgDbPath))-  , make_ord_flag defFlag "clear-package-db"      (NoArg clearPkgDb)-  , make_ord_flag defFlag "no-global-package-db"  (NoArg removeGlobalPkgDb)-  , make_ord_flag defFlag "no-user-package-db"    (NoArg removeUserPkgDb)-  , make_ord_flag defFlag "global-package-db"-      (NoArg (addPkgDbRef GlobalPkgDb))-  , make_ord_flag defFlag "user-package-db"-      (NoArg (addPkgDbRef UserPkgDb))-    -- backwards compat with GHC<=7.4 :-  , make_dep_flag defFlag "package-conf"-      (HasArg $ addPkgDbRef . PkgDbPath) "Use -package-db instead"-  , make_dep_flag defFlag "no-user-package-conf"-      (NoArg removeUserPkgDb)              "Use -no-user-package-db instead"-  , make_ord_flag defGhcFlag "package-name"       (HasArg $ \name -> do-                                      upd (setUnitId name))-                                      -- TODO: Since we JUST deprecated-                                      -- -this-package-key, let's keep this-                                      -- undeprecated for another cycle.-                                      -- Deprecate this eventually.-                                      -- deprecate "Use -this-unit-id instead")-  , make_dep_flag defGhcFlag "this-package-key"   (HasArg $ upd . setUnitId)-                                                  "Use -this-unit-id instead"-  , make_ord_flag defGhcFlag "this-unit-id"       (hasArg setUnitId)-  , make_ord_flag defFlag "package"               (HasArg exposePackage)-  , make_ord_flag defFlag "plugin-package-id"     (HasArg exposePluginPackageId)-  , make_ord_flag defFlag "plugin-package"        (HasArg exposePluginPackage)-  , make_ord_flag defFlag "package-id"            (HasArg exposePackageId)-  , make_ord_flag defFlag "hide-package"          (HasArg hidePackage)-  , make_ord_flag defFlag "hide-all-packages"-      (NoArg (setGeneralFlag Opt_HideAllPackages))-  , make_ord_flag defFlag "hide-all-plugin-packages"-      (NoArg (setGeneralFlag Opt_HideAllPluginPackages))-  , make_ord_flag defFlag "package-env"           (HasArg setPackageEnv)-  , make_ord_flag defFlag "ignore-package"        (HasArg ignorePackage)-  , make_dep_flag defFlag "syslib" (HasArg exposePackage) "Use -package instead"-  , make_ord_flag defFlag "distrust-all-packages"-      (NoArg (setGeneralFlag Opt_DistrustAllPackages))-  , make_ord_flag defFlag "trust"                 (HasArg trustPackage)-  , make_ord_flag defFlag "distrust"              (HasArg distrustPackage)-  ]-  where-    setPackageEnv env = upd $ \s -> s { packageEnv = Just env }---- | Make a list of flags for shell completion.--- Filter all available flags into two groups, for interactive GHC vs all other.-flagsForCompletion :: Bool -> [String]-flagsForCompletion isInteractive-    = [ '-':flagName flag-      | flag <- flagsAll-      , modeFilter (flagGhcMode flag)-      ]-    where-      modeFilter AllModes = True-      modeFilter OnlyGhci = isInteractive-      modeFilter OnlyGhc = not isInteractive-      modeFilter HiddenFlag = False--type TurnOnFlag = Bool   -- True  <=> we are turning the flag on-                         -- False <=> we are turning the flag off-turnOn  :: TurnOnFlag; turnOn  = True-turnOff :: TurnOnFlag; turnOff = False--data FlagSpec flag-   = FlagSpec-       { flagSpecName :: String   -- ^ Flag in string form-       , flagSpecFlag :: flag     -- ^ Flag in internal form-       , flagSpecAction :: (TurnOnFlag -> DynP ())-           -- ^ Extra action to run when the flag is found-           -- Typically, emit a warning or error-       , flagSpecGhcMode :: GhcFlagMode-           -- ^ In which ghc mode the flag has effect-       }---- | Define a new flag.-flagSpec :: String -> flag -> (Deprecation, FlagSpec flag)-flagSpec name flag = flagSpec' name flag nop---- | Define a new flag with an effect.-flagSpec' :: String -> flag -> (TurnOnFlag -> DynP ())-          -> (Deprecation, FlagSpec flag)-flagSpec' name flag act = (NotDeprecated, FlagSpec name flag act AllModes)---- | Define a new deprecated flag with an effect.-depFlagSpecOp :: String -> flag -> (TurnOnFlag -> DynP ()) -> String-            -> (Deprecation, FlagSpec flag)-depFlagSpecOp name flag act dep =-    (Deprecated, snd (flagSpec' name flag (\f -> act f >> deprecate dep)))---- | Define a new deprecated flag.-depFlagSpec :: String -> flag -> String-            -> (Deprecation, FlagSpec flag)-depFlagSpec name flag dep = depFlagSpecOp name flag nop dep---- | Define a new deprecated flag with an effect where the deprecation message--- depends on the flag value-depFlagSpecOp' :: String-             -> flag-             -> (TurnOnFlag -> DynP ())-             -> (TurnOnFlag -> String)-             -> (Deprecation, FlagSpec flag)-depFlagSpecOp' name flag act dep =-    (Deprecated, FlagSpec name flag (\f -> act f >> (deprecate $ dep f))-                                                                       AllModes)---- | Define a new deprecated flag where the deprecation message--- depends on the flag value-depFlagSpec' :: String-             -> flag-             -> (TurnOnFlag -> String)-             -> (Deprecation, FlagSpec flag)-depFlagSpec' name flag dep = depFlagSpecOp' name flag nop dep----- | Define a new deprecated flag where the deprecation message--- is shown depending on the flag value-depFlagSpecCond :: String-                -> flag-                -> (TurnOnFlag -> Bool)-                -> String-                -> (Deprecation, FlagSpec flag)-depFlagSpecCond name flag cond dep =-    (Deprecated, FlagSpec name flag (\f -> when (cond f) $ deprecate dep)-                                                                       AllModes)---- | Define a new flag for GHCi.-flagGhciSpec :: String -> flag -> (Deprecation, FlagSpec flag)-flagGhciSpec name flag = flagGhciSpec' name flag nop---- | Define a new flag for GHCi with an effect.-flagGhciSpec' :: String -> flag -> (TurnOnFlag -> DynP ())-              -> (Deprecation, FlagSpec flag)-flagGhciSpec' name flag act = (NotDeprecated, FlagSpec name flag act OnlyGhci)---- | Define a new flag invisible to CLI completion.-flagHiddenSpec :: String -> flag -> (Deprecation, FlagSpec flag)-flagHiddenSpec name flag = flagHiddenSpec' name flag nop---- | Define a new flag invisible to CLI completion with an effect.-flagHiddenSpec' :: String -> flag -> (TurnOnFlag -> DynP ())-                -> (Deprecation, FlagSpec flag)-flagHiddenSpec' name flag act = (NotDeprecated, FlagSpec name flag act-                                                                     HiddenFlag)---- | Hide a 'FlagSpec' from being displayed in @--show-options@.------ This is for example useful for flags that are obsolete, but should not--- (yet) be deprecated for compatibility reasons.-hideFlag :: (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)-hideFlag (dep, fs) = (dep, fs { flagSpecGhcMode = HiddenFlag })--mkFlag :: TurnOnFlag            -- ^ True <=> it should be turned on-       -> String                -- ^ The flag prefix-       -> (flag -> DynP ())     -- ^ What to do when the flag is found-       -> (Deprecation, FlagSpec flag)  -- ^ Specification of-                                        -- this particular flag-       -> (Deprecation, Flag (CmdLineP DynFlags))-mkFlag turn_on flagPrefix f (dep, (FlagSpec name flag extra_action mode))-    = (dep,-       Flag (flagPrefix ++ name) (NoArg (f flag >> extra_action turn_on)) mode)--deprecatedForExtension :: String -> TurnOnFlag -> String-deprecatedForExtension lang turn_on-    = "use -X" ++ flag ++-      " or pragma {-# LANGUAGE " ++ flag ++ " #-} instead"-    where-      flag | turn_on   = lang-           | otherwise = "No" ++ lang--useInstead :: String -> String -> TurnOnFlag -> String-useInstead prefix flag turn_on-  = "Use " ++ prefix ++ no ++ flag ++ " instead"-  where-    no = if turn_on then "" else "no-"--nop :: TurnOnFlag -> DynP ()-nop _ = return ()---- | Find the 'FlagSpec' for a 'WarningFlag'.-flagSpecOf :: WarningFlag -> Maybe (FlagSpec WarningFlag)-flagSpecOf flag = listToMaybe $ filter check wWarningFlags-  where-    check fs = flagSpecFlag fs == flag---- | These @-W\<blah\>@ flags can all be reversed with @-Wno-\<blah\>@-wWarningFlags :: [FlagSpec WarningFlag]-wWarningFlags = map snd (sortBy (comparing fst) wWarningFlagsDeps)--wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]-wWarningFlagsDeps = [--- See Note [Updating flag description in the User's Guide]--- See Note [Supporting CLI completion]--- Please keep the list of flags below sorted alphabetically-  flagSpec "alternative-layout-rule-transitional"-                                      Opt_WarnAlternativeLayoutRuleTransitional,-  depFlagSpec "auto-orphans"             Opt_WarnAutoOrphans-    "it has no effect",-  flagSpec "cpp-undef"                   Opt_WarnCPPUndef,-  flagSpec "unbanged-strict-patterns"    Opt_WarnUnbangedStrictPatterns,-  flagSpec "deferred-type-errors"        Opt_WarnDeferredTypeErrors,-  flagSpec "deferred-out-of-scope-variables"-                                         Opt_WarnDeferredOutOfScopeVariables,-  flagSpec "deprecations"                Opt_WarnWarningsDeprecations,-  flagSpec "deprecated-flags"            Opt_WarnDeprecatedFlags,-  flagSpec "deriving-defaults"           Opt_WarnDerivingDefaults,-  flagSpec "deriving-typeable"           Opt_WarnDerivingTypeable,-  flagSpec "dodgy-exports"               Opt_WarnDodgyExports,-  flagSpec "dodgy-foreign-imports"       Opt_WarnDodgyForeignImports,-  flagSpec "dodgy-imports"               Opt_WarnDodgyImports,-  flagSpec "empty-enumerations"          Opt_WarnEmptyEnumerations,-  depFlagSpec "duplicate-constraints"    Opt_WarnDuplicateConstraints-    "it is subsumed by -Wredundant-constraints",-  flagSpec "redundant-constraints"       Opt_WarnRedundantConstraints,-  flagSpec "duplicate-exports"           Opt_WarnDuplicateExports,-  depFlagSpec "hi-shadowing"                Opt_WarnHiShadows-    "it is not used, and was never implemented",-  flagSpec "inaccessible-code"           Opt_WarnInaccessibleCode,-  flagSpec "implicit-prelude"            Opt_WarnImplicitPrelude,-  depFlagSpec "implicit-kind-vars"       Opt_WarnImplicitKindVars-    "it is now an error",-  flagSpec "incomplete-patterns"         Opt_WarnIncompletePatterns,-  flagSpec "incomplete-record-updates"   Opt_WarnIncompletePatternsRecUpd,-  flagSpec "incomplete-uni-patterns"     Opt_WarnIncompleteUniPatterns,-  flagSpec "inline-rule-shadowing"       Opt_WarnInlineRuleShadowing,-  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,-  flagSpec "missing-methods"             Opt_WarnMissingMethods,-  flagSpec "missing-monadfail-instances" Opt_WarnMissingMonadFailInstances,-  flagSpec "semigroup"                   Opt_WarnSemigroup,-  flagSpec "missing-signatures"          Opt_WarnMissingSignatures,-  depFlagSpec "missing-exported-sigs"    Opt_WarnMissingExportedSignatures-    "it is replaced by -Wmissing-exported-signatures",-  flagSpec "missing-exported-signatures" Opt_WarnMissingExportedSignatures,-  flagSpec "monomorphism-restriction"    Opt_WarnMonomorphism,-  flagSpec "name-shadowing"              Opt_WarnNameShadowing,-  flagSpec "noncanonical-monad-instances"-                                         Opt_WarnNonCanonicalMonadInstances,-  depFlagSpec "noncanonical-monadfail-instances"-                                         Opt_WarnNonCanonicalMonadInstances-    "fail is no longer a method of Monad",-  flagSpec "noncanonical-monoid-instances"-                                         Opt_WarnNonCanonicalMonoidInstances,-  flagSpec "orphans"                     Opt_WarnOrphans,-  flagSpec "overflowed-literals"         Opt_WarnOverflowedLiterals,-  flagSpec "overlapping-patterns"        Opt_WarnOverlappingPatterns,-  flagSpec "missed-specialisations"      Opt_WarnMissedSpecs,-  flagSpec "missed-specializations"      Opt_WarnMissedSpecs,-  flagSpec "all-missed-specialisations"  Opt_WarnAllMissedSpecs,-  flagSpec "all-missed-specializations"  Opt_WarnAllMissedSpecs,-  flagSpec' "safe"                       Opt_WarnSafe setWarnSafe,-  flagSpec "trustworthy-safe"            Opt_WarnTrustworthySafe,-  flagSpec "inferred-safe-imports"       Opt_WarnInferredSafeImports,-  flagSpec "missing-safe-haskell-mode"   Opt_WarnMissingSafeHaskellMode,-  flagSpec "tabs"                        Opt_WarnTabs,-  flagSpec "type-defaults"               Opt_WarnTypeDefaults,-  flagSpec "typed-holes"                 Opt_WarnTypedHoles,-  flagSpec "partial-type-signatures"     Opt_WarnPartialTypeSignatures,-  flagSpec "unrecognised-pragmas"        Opt_WarnUnrecognisedPragmas,-  flagSpec' "unsafe"                     Opt_WarnUnsafe setWarnUnsafe,-  flagSpec "unsupported-calling-conventions"-                                         Opt_WarnUnsupportedCallingConventions,-  flagSpec "unsupported-llvm-version"    Opt_WarnUnsupportedLlvmVersion,-  flagSpec "missed-extra-shared-lib"     Opt_WarnMissedExtraSharedLib,-  flagSpec "unticked-promoted-constructors"-                                         Opt_WarnUntickedPromotedConstructors,-  flagSpec "unused-do-bind"              Opt_WarnUnusedDoBind,-  flagSpec "unused-foralls"              Opt_WarnUnusedForalls,-  flagSpec "unused-imports"              Opt_WarnUnusedImports,-  flagSpec "unused-local-binds"          Opt_WarnUnusedLocalBinds,-  flagSpec "unused-matches"              Opt_WarnUnusedMatches,-  flagSpec "unused-pattern-binds"        Opt_WarnUnusedPatternBinds,-  flagSpec "unused-top-binds"            Opt_WarnUnusedTopBinds,-  flagSpec "unused-type-patterns"        Opt_WarnUnusedTypePatterns,-  flagSpec "unused-record-wildcards"     Opt_WarnUnusedRecordWildcards,-  flagSpec "redundant-record-wildcards"  Opt_WarnRedundantRecordWildcards,-  flagSpec "warnings-deprecations"       Opt_WarnWarningsDeprecations,-  flagSpec "wrong-do-bind"               Opt_WarnWrongDoBind,-  flagSpec "missing-pattern-synonym-signatures"-                                    Opt_WarnMissingPatternSynonymSignatures,-  flagSpec "missing-deriving-strategies" Opt_WarnMissingDerivingStrategies,-  flagSpec "simplifiable-class-constraints" Opt_WarnSimplifiableClassConstraints,-  flagSpec "missing-home-modules"        Opt_WarnMissingHomeModules,-  flagSpec "unrecognised-warning-flags"  Opt_WarnUnrecognisedWarningFlags,-  flagSpec "star-binder"                 Opt_WarnStarBinder,-  flagSpec "star-is-type"                Opt_WarnStarIsType,-  depFlagSpec "missing-space-after-bang" Opt_WarnSpaceAfterBang-    "bang patterns can no longer be written with a space",-  flagSpec "partial-fields"              Opt_WarnPartialFields,-  flagSpec "prepositive-qualified-module"-                                         Opt_WarnPrepositiveQualifiedModule,-  flagSpec "unused-packages"             Opt_WarnUnusedPackages- ]---- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@-negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]-negatableFlagsDeps = [-  flagGhciSpec "ignore-dot-ghci"         Opt_IgnoreDotGhci ]---- | These @-d\<blah\>@ flags can all be reversed with @-dno-\<blah\>@-dFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]-dFlagsDeps = [--- See Note [Updating flag description in the User's Guide]--- See Note [Supporting CLI completion]--- Please keep the list of flags below sorted alphabetically-  flagSpec "ppr-case-as-let"            Opt_PprCaseAsLet,-  depFlagSpec' "ppr-ticks"              Opt_PprShowTicks-     (\turn_on -> useInstead "-d" "suppress-ticks" (not turn_on)),-  flagSpec "suppress-ticks"             Opt_SuppressTicks,-  depFlagSpec' "suppress-stg-free-vars" Opt_SuppressStgExts-     (useInstead "-d" "suppress-stg-exts"),-  flagSpec "suppress-stg-exts"          Opt_SuppressStgExts,-  flagSpec "suppress-coercions"         Opt_SuppressCoercions,-  flagSpec "suppress-idinfo"            Opt_SuppressIdInfo,-  flagSpec "suppress-unfoldings"        Opt_SuppressUnfoldings,-  flagSpec "suppress-module-prefixes"   Opt_SuppressModulePrefixes,-  flagSpec "suppress-timestamps"        Opt_SuppressTimestamps,-  flagSpec "suppress-type-applications" Opt_SuppressTypeApplications,-  flagSpec "suppress-type-signatures"   Opt_SuppressTypeSignatures,-  flagSpec "suppress-uniques"           Opt_SuppressUniques,-  flagSpec "suppress-var-kinds"         Opt_SuppressVarKinds-  ]---- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@-fFlags :: [FlagSpec GeneralFlag]-fFlags = map snd fFlagsDeps--fFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]-fFlagsDeps = [--- See Note [Updating flag description in the User's Guide]--- See Note [Supporting CLI completion]--- Please keep the list of flags below sorted alphabetically-  flagSpec "asm-shortcutting"                 Opt_AsmShortcutting,-  flagGhciSpec "break-on-error"               Opt_BreakOnError,-  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,-  flagSpec "cmm-sink"                         Opt_CmmSink,-  flagSpec "cse"                              Opt_CSE,-  flagSpec "stg-cse"                          Opt_StgCSE,-  flagSpec "stg-lift-lams"                    Opt_StgLiftLams,-  flagSpec "cpr-anal"                         Opt_CprAnal,-  flagSpec "defer-diagnostics"                Opt_DeferDiagnostics,-  flagSpec "defer-type-errors"                Opt_DeferTypeErrors,-  flagSpec "defer-typed-holes"                Opt_DeferTypedHoles,-  flagSpec "defer-out-of-scope-variables"     Opt_DeferOutOfScopeVariables,-  flagSpec "diagnostics-show-caret"           Opt_DiagnosticsShowCaret,-  flagSpec "dicts-cheap"                      Opt_DictsCheap,-  flagSpec "dicts-strict"                     Opt_DictsStrict,-  flagSpec "dmd-tx-dict-sel"                  Opt_DmdTxDictSel,-  flagSpec "do-eta-reduction"                 Opt_DoEtaReduction,-  flagSpec "do-lambda-eta-expansion"          Opt_DoLambdaEtaExpansion,-  flagSpec "eager-blackholing"                Opt_EagerBlackHoling,-  flagSpec "embed-manifest"                   Opt_EmbedManifest,-  flagSpec "enable-rewrite-rules"             Opt_EnableRewriteRules,-  flagSpec "enable-th-splice-warnings"        Opt_EnableThSpliceWarnings,-  flagSpec "error-spans"                      Opt_ErrorSpans,-  flagSpec "excess-precision"                 Opt_ExcessPrecision,-  flagSpec "expose-all-unfoldings"            Opt_ExposeAllUnfoldings,-  flagSpec "external-dynamic-refs"            Opt_ExternalDynamicRefs,-  flagSpec "external-interpreter"             Opt_ExternalInterpreter,-  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,-  flagSpec "ghci-history"                     Opt_GhciHistory,-  flagSpec "ghci-leak-check"                  Opt_GhciLeakCheck,-  flagSpec "validate-ide-info"                Opt_ValidateHie,-  flagGhciSpec "local-ghci-history"           Opt_LocalGhciHistory,-  flagGhciSpec "no-it"                        Opt_NoIt,-  flagSpec "ghci-sandbox"                     Opt_GhciSandbox,-  flagSpec "helpful-errors"                   Opt_HelpfulErrors,-  flagSpec "hpc"                              Opt_Hpc,-  flagSpec "ignore-asserts"                   Opt_IgnoreAsserts,-  flagSpec "ignore-interface-pragmas"         Opt_IgnoreInterfacePragmas,-  flagGhciSpec "implicit-import-qualified"    Opt_ImplicitImportQualified,-  flagSpec "irrefutable-tuples"               Opt_IrrefutableTuples,-  flagSpec "keep-going"                       Opt_KeepGoing,-  flagSpec "kill-absence"                     Opt_KillAbsence,-  flagSpec "kill-one-shot"                    Opt_KillOneShot,-  flagSpec "late-dmd-anal"                    Opt_LateDmdAnal,-  flagSpec "late-specialise"                  Opt_LateSpecialise,-  flagSpec "liberate-case"                    Opt_LiberateCase,-  flagHiddenSpec "llvm-tbaa"                  Opt_LlvmTBAA,-  flagHiddenSpec "llvm-fill-undef-with-garbage" Opt_LlvmFillUndefWithGarbage,-  flagSpec "loopification"                    Opt_Loopification,-  flagSpec "block-layout-cfg"                 Opt_CfgBlocklayout,-  flagSpec "block-layout-weightless"          Opt_WeightlessBlocklayout,-  flagSpec "omit-interface-pragmas"           Opt_OmitInterfacePragmas,-  flagSpec "omit-yields"                      Opt_OmitYields,-  flagSpec "optimal-applicative-do"           Opt_OptimalApplicativeDo,-  flagSpec "pedantic-bottoms"                 Opt_PedanticBottoms,-  flagSpec "pre-inlining"                     Opt_SimplPreInlining,-  flagGhciSpec "print-bind-contents"          Opt_PrintBindContents,-  flagGhciSpec "print-bind-result"            Opt_PrintBindResult,-  flagGhciSpec "print-evld-with-show"         Opt_PrintEvldWithShow,-  flagSpec "print-explicit-foralls"           Opt_PrintExplicitForalls,-  flagSpec "print-explicit-kinds"             Opt_PrintExplicitKinds,-  flagSpec "print-explicit-coercions"         Opt_PrintExplicitCoercions,-  flagSpec "print-explicit-runtime-reps"      Opt_PrintExplicitRuntimeReps,-  flagSpec "print-equality-relations"         Opt_PrintEqualityRelations,-  flagSpec "print-axiom-incomps"              Opt_PrintAxiomIncomps,-  flagSpec "print-unicode-syntax"             Opt_PrintUnicodeSyntax,-  flagSpec "print-expanded-synonyms"          Opt_PrintExpandedSynonyms,-  flagSpec "print-potential-instances"        Opt_PrintPotentialInstances,-  flagSpec "print-typechecker-elaboration"    Opt_PrintTypecheckerElaboration,-  flagSpec "prof-cafs"                        Opt_AutoSccsOnIndividualCafs,-  flagSpec "prof-count-entries"               Opt_ProfCountEntries,-  flagSpec "regs-graph"                       Opt_RegsGraph,-  flagSpec "regs-iterative"                   Opt_RegsIterative,-  depFlagSpec' "rewrite-rules"                Opt_EnableRewriteRules-   (useInstead "-f" "enable-rewrite-rules"),-  flagSpec "shared-implib"                    Opt_SharedImplib,-  flagSpec "spec-constr"                      Opt_SpecConstr,-  flagSpec "spec-constr-keen"                 Opt_SpecConstrKeen,-  flagSpec "specialise"                       Opt_Specialise,-  flagSpec "specialize"                       Opt_Specialise,-  flagSpec "specialise-aggressively"          Opt_SpecialiseAggressively,-  flagSpec "specialize-aggressively"          Opt_SpecialiseAggressively,-  flagSpec "cross-module-specialise"          Opt_CrossModuleSpecialise,-  flagSpec "cross-module-specialize"          Opt_CrossModuleSpecialise,-  flagSpec "static-argument-transformation"   Opt_StaticArgumentTransformation,-  flagSpec "strictness"                       Opt_Strictness,-  flagSpec "use-rpaths"                       Opt_RPath,-  flagSpec "write-interface"                  Opt_WriteInterface,-  flagSpec "write-ide-info"                   Opt_WriteHie,-  flagSpec "unbox-small-strict-fields"        Opt_UnboxSmallStrictFields,-  flagSpec "unbox-strict-fields"              Opt_UnboxStrictFields,-  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 "num-constant-folding"             Opt_NumConstantFolding,-  flagSpec "show-warning-groups"              Opt_ShowWarnGroups,-  flagSpec "hide-source-paths"                Opt_HideSourcePaths,-  flagSpec "show-loaded-modules"              Opt_ShowLoadedModules,-  flagSpec "whole-archive-hs-libs"            Opt_WholeArchiveHsLibs,-  flagSpec "keep-cafs"                        Opt_KeepCAFs-  ]-  ++ fHoleFlags---- | These @-f\<blah\>@ flags have to do with the typed-hole error message or--- the valid hole fits in that message. See Note [Valid hole fits include ...]--- in the TcHoleErrors module. These flags can all be reversed with--- @-fno-\<blah\>@-fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)]-fHoleFlags = [-  flagSpec "show-hole-constraints"            Opt_ShowHoleConstraints,-  depFlagSpec' "show-valid-substitutions"     Opt_ShowValidHoleFits-   (useInstead "-f" "show-valid-hole-fits"),-  flagSpec "show-valid-hole-fits"             Opt_ShowValidHoleFits,-  -- Sorting settings-  flagSpec "sort-valid-hole-fits"             Opt_SortValidHoleFits,-  flagSpec "sort-by-size-hole-fits"           Opt_SortBySizeHoleFits,-  flagSpec "sort-by-subsumption-hole-fits"    Opt_SortBySubsumHoleFits,-  flagSpec "abstract-refinement-hole-fits"    Opt_AbstractRefHoleFits,-  -- Output format settings-  flagSpec "show-hole-matches-of-hole-fits"   Opt_ShowMatchesOfHoleFits,-  flagSpec "show-provenance-of-hole-fits"     Opt_ShowProvOfHoleFits,-  flagSpec "show-type-of-hole-fits"           Opt_ShowTypeOfHoleFits,-  flagSpec "show-type-app-of-hole-fits"       Opt_ShowTypeAppOfHoleFits,-  flagSpec "show-type-app-vars-of-hole-fits"  Opt_ShowTypeAppVarsOfHoleFits,-  flagSpec "show-docs-of-hole-fits"           Opt_ShowDocsOfHoleFits,-  flagSpec "unclutter-valid-hole-fits"        Opt_UnclutterValidHoleFits-  ]---- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@-fLangFlags :: [FlagSpec LangExt.Extension]-fLangFlags = map snd fLangFlagsDeps--fLangFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]-fLangFlagsDeps = [--- See Note [Updating flag description in the User's Guide]--- See Note [Supporting CLI completion]-  depFlagSpecOp' "th"                           LangExt.TemplateHaskell-    checkTemplateHaskellOk-    (deprecatedForExtension "TemplateHaskell"),-  depFlagSpec' "fi"                             LangExt.ForeignFunctionInterface-    (deprecatedForExtension "ForeignFunctionInterface"),-  depFlagSpec' "ffi"                            LangExt.ForeignFunctionInterface-    (deprecatedForExtension "ForeignFunctionInterface"),-  depFlagSpec' "arrows"                         LangExt.Arrows-    (deprecatedForExtension "Arrows"),-  depFlagSpec' "implicit-prelude"               LangExt.ImplicitPrelude-    (deprecatedForExtension "ImplicitPrelude"),-  depFlagSpec' "bang-patterns"                  LangExt.BangPatterns-    (deprecatedForExtension "BangPatterns"),-  depFlagSpec' "monomorphism-restriction"       LangExt.MonomorphismRestriction-    (deprecatedForExtension "MonomorphismRestriction"),-  depFlagSpec' "mono-pat-binds"                 LangExt.MonoPatBinds-    (deprecatedForExtension "MonoPatBinds"),-  depFlagSpec' "extended-default-rules"         LangExt.ExtendedDefaultRules-    (deprecatedForExtension "ExtendedDefaultRules"),-  depFlagSpec' "implicit-params"                LangExt.ImplicitParams-    (deprecatedForExtension "ImplicitParams"),-  depFlagSpec' "scoped-type-variables"          LangExt.ScopedTypeVariables-    (deprecatedForExtension "ScopedTypeVariables"),-  depFlagSpec' "allow-overlapping-instances"    LangExt.OverlappingInstances-    (deprecatedForExtension "OverlappingInstances"),-  depFlagSpec' "allow-undecidable-instances"    LangExt.UndecidableInstances-    (deprecatedForExtension "UndecidableInstances"),-  depFlagSpec' "allow-incoherent-instances"     LangExt.IncoherentInstances-    (deprecatedForExtension "IncoherentInstances")-  ]--supportedLanguages :: [String]-supportedLanguages = map (flagSpecName . snd) languageFlagsDeps--supportedLanguageOverlays :: [String]-supportedLanguageOverlays = map (flagSpecName . snd) safeHaskellFlagsDeps--supportedExtensions :: PlatformMini -> [String]-supportedExtensions targetPlatformMini = concatMap toFlagSpecNamePair xFlags-  where-    toFlagSpecNamePair flg-      -- IMPORTANT! Make sure that `ghc --supported-extensions` omits-      -- "TemplateHaskell"/"QuasiQuotes" when it's known not to work out of the-      -- box. See also GHC #11102 and #16331 for more details about-      -- the rationale-      | isAIX, flagSpecFlag flg == LangExt.TemplateHaskell  = [noName]-      | isAIX, flagSpecFlag flg == LangExt.QuasiQuotes      = [noName]-      | otherwise = [name, noName]-      where-        isAIX = platformMini_os targetPlatformMini == OSAIX-        noName = "No" ++ name-        name = flagSpecName flg--supportedLanguagesAndExtensions :: PlatformMini -> [String]-supportedLanguagesAndExtensions targetPlatformMini =-    supportedLanguages ++ supportedLanguageOverlays ++ supportedExtensions targetPlatformMini---- | These -X<blah> flags cannot be reversed with -XNo<blah>-languageFlagsDeps :: [(Deprecation, FlagSpec Language)]-languageFlagsDeps = [-  flagSpec "Haskell98"   Haskell98,-  flagSpec "Haskell2010" Haskell2010-  ]---- | These -X<blah> flags cannot be reversed with -XNo<blah>--- They are used to place hard requirements on what GHC Haskell language--- features can be used.-safeHaskellFlagsDeps :: [(Deprecation, FlagSpec SafeHaskellMode)]-safeHaskellFlagsDeps = [mkF Sf_Unsafe, mkF Sf_Trustworthy, mkF Sf_Safe]-    where mkF flag = flagSpec (show flag) flag---- | These -X<blah> flags can all be reversed with -XNo<blah>-xFlags :: [FlagSpec LangExt.Extension]-xFlags = map snd xFlagsDeps--xFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]-xFlagsDeps = [--- See Note [Updating flag description in the User's Guide]--- See Note [Supporting CLI completion]--- See Note [Adding a language extension]--- Please keep the list of flags below sorted alphabetically-  flagSpec "AllowAmbiguousTypes"              LangExt.AllowAmbiguousTypes,-  flagSpec "AlternativeLayoutRule"            LangExt.AlternativeLayoutRule,-  flagSpec "AlternativeLayoutRuleTransitional"-                                              LangExt.AlternativeLayoutRuleTransitional,-  flagSpec "Arrows"                           LangExt.Arrows,-  depFlagSpecCond "AutoDeriveTypeable"        LangExt.AutoDeriveTypeable-    id-         ("Typeable instances are created automatically " ++-                     "for all types since GHC 8.2."),-  flagSpec "BangPatterns"                     LangExt.BangPatterns,-  flagSpec "BinaryLiterals"                   LangExt.BinaryLiterals,-  flagSpec "CApiFFI"                          LangExt.CApiFFI,-  flagSpec "CPP"                              LangExt.Cpp,-  flagSpec "CUSKs"                            LangExt.CUSKs,-  flagSpec "ConstrainedClassMethods"          LangExt.ConstrainedClassMethods,-  flagSpec "ConstraintKinds"                  LangExt.ConstraintKinds,-  flagSpec "DataKinds"                        LangExt.DataKinds,-  depFlagSpecCond "DatatypeContexts"          LangExt.DatatypeContexts-    id-         ("It was widely considered a misfeature, " ++-                     "and has been removed from the Haskell language."),-  flagSpec "DefaultSignatures"                LangExt.DefaultSignatures,-  flagSpec "DeriveAnyClass"                   LangExt.DeriveAnyClass,-  flagSpec "DeriveDataTypeable"               LangExt.DeriveDataTypeable,-  flagSpec "DeriveFoldable"                   LangExt.DeriveFoldable,-  flagSpec "DeriveFunctor"                    LangExt.DeriveFunctor,-  flagSpec "DeriveGeneric"                    LangExt.DeriveGeneric,-  flagSpec "DeriveLift"                       LangExt.DeriveLift,-  flagSpec "DeriveTraversable"                LangExt.DeriveTraversable,-  flagSpec "DerivingStrategies"               LangExt.DerivingStrategies,-  flagSpec "DerivingVia"                      LangExt.DerivingVia,-  flagSpec "DisambiguateRecordFields"         LangExt.DisambiguateRecordFields,-  flagSpec "DoAndIfThenElse"                  LangExt.DoAndIfThenElse,-  flagSpec "BlockArguments"                   LangExt.BlockArguments,-  depFlagSpec' "DoRec"                        LangExt.RecursiveDo-    (deprecatedForExtension "RecursiveDo"),-  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,-  flagSpec "ExtendedDefaultRules"             LangExt.ExtendedDefaultRules,-  flagSpec "FlexibleContexts"                 LangExt.FlexibleContexts,-  flagSpec "FlexibleInstances"                LangExt.FlexibleInstances,-  flagSpec "ForeignFunctionInterface"         LangExt.ForeignFunctionInterface,-  flagSpec "FunctionalDependencies"           LangExt.FunctionalDependencies,-  flagSpec "GADTSyntax"                       LangExt.GADTSyntax,-  flagSpec "GADTs"                            LangExt.GADTs,-  flagSpec "GHCForeignImportPrim"             LangExt.GHCForeignImportPrim,-  flagSpec' "GeneralizedNewtypeDeriving"      LangExt.GeneralizedNewtypeDeriving-                                              setGenDeriving,-  flagSpec' "GeneralisedNewtypeDeriving"      LangExt.GeneralizedNewtypeDeriving-                                              setGenDeriving,-  flagSpec "ImplicitParams"                   LangExt.ImplicitParams,-  flagSpec "ImplicitPrelude"                  LangExt.ImplicitPrelude,-  flagSpec "ImportQualifiedPost"              LangExt.ImportQualifiedPost,-  flagSpec "ImpredicativeTypes"               LangExt.ImpredicativeTypes,-  flagSpec' "IncoherentInstances"             LangExt.IncoherentInstances-                                              setIncoherentInsts,-  flagSpec "TypeFamilyDependencies"           LangExt.TypeFamilyDependencies,-  flagSpec "InstanceSigs"                     LangExt.InstanceSigs,-  flagSpec "ApplicativeDo"                    LangExt.ApplicativeDo,-  flagSpec "InterruptibleFFI"                 LangExt.InterruptibleFFI,-  flagSpec "JavaScriptFFI"                    LangExt.JavaScriptFFI,-  flagSpec "KindSignatures"                   LangExt.KindSignatures,-  flagSpec "LambdaCase"                       LangExt.LambdaCase,-  flagSpec "LiberalTypeSynonyms"              LangExt.LiberalTypeSynonyms,-  flagSpec "MagicHash"                        LangExt.MagicHash,-  flagSpec "MonadComprehensions"              LangExt.MonadComprehensions,-  depFlagSpec "MonadFailDesugaring"           LangExt.MonadFailDesugaring-    "MonadFailDesugaring is now the default behavior",-  flagSpec "MonoLocalBinds"                   LangExt.MonoLocalBinds,-  depFlagSpecCond "MonoPatBinds"              LangExt.MonoPatBinds-    id-         "Experimental feature now removed; has no effect",-  flagSpec "MonomorphismRestriction"          LangExt.MonomorphismRestriction,-  flagSpec "MultiParamTypeClasses"            LangExt.MultiParamTypeClasses,-  flagSpec "MultiWayIf"                       LangExt.MultiWayIf,-  flagSpec "NumericUnderscores"               LangExt.NumericUnderscores,-  flagSpec "NPlusKPatterns"                   LangExt.NPlusKPatterns,-  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"),-  flagSpec "NumDecimals"                      LangExt.NumDecimals,-  depFlagSpecOp "OverlappingInstances"        LangExt.OverlappingInstances-    setOverlappingInsts-    "instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS",-  flagSpec "OverloadedLabels"                 LangExt.OverloadedLabels,-  flagSpec "OverloadedLists"                  LangExt.OverloadedLists,-  flagSpec "OverloadedStrings"                LangExt.OverloadedStrings,-  flagSpec "PackageImports"                   LangExt.PackageImports,-  flagSpec "ParallelArrays"                   LangExt.ParallelArrays,-  flagSpec "ParallelListComp"                 LangExt.ParallelListComp,-  flagSpec "PartialTypeSignatures"            LangExt.PartialTypeSignatures,-  flagSpec "PatternGuards"                    LangExt.PatternGuards,-  depFlagSpec' "PatternSignatures"            LangExt.ScopedTypeVariables-    (deprecatedForExtension "ScopedTypeVariables"),-  flagSpec "PatternSynonyms"                  LangExt.PatternSynonyms,-  flagSpec "PolyKinds"                        LangExt.PolyKinds,-  flagSpec "PolymorphicComponents"            LangExt.RankNTypes,-  flagSpec "QuantifiedConstraints"            LangExt.QuantifiedConstraints,-  flagSpec "PostfixOperators"                 LangExt.PostfixOperators,-  flagSpec "QuasiQuotes"                      LangExt.QuasiQuotes,-  flagSpec "Rank2Types"                       LangExt.RankNTypes,-  flagSpec "RankNTypes"                       LangExt.RankNTypes,-  flagSpec "RebindableSyntax"                 LangExt.RebindableSyntax,-  depFlagSpec' "RecordPuns"                   LangExt.RecordPuns-    (deprecatedForExtension "NamedFieldPuns"),-  flagSpec "RecordWildCards"                  LangExt.RecordWildCards,-  flagSpec "RecursiveDo"                      LangExt.RecursiveDo,-  flagSpec "RelaxedLayout"                    LangExt.RelaxedLayout,-  depFlagSpecCond "RelaxedPolyRec"            LangExt.RelaxedPolyRec-    not-         "You can't turn off RelaxedPolyRec any more",-  flagSpec "RoleAnnotations"                  LangExt.RoleAnnotations,-  flagSpec "ScopedTypeVariables"              LangExt.ScopedTypeVariables,-  flagSpec "StandaloneDeriving"               LangExt.StandaloneDeriving,-  flagSpec "StarIsType"                       LangExt.StarIsType,-  flagSpec "StaticPointers"                   LangExt.StaticPointers,-  flagSpec "Strict"                           LangExt.Strict,-  flagSpec "StrictData"                       LangExt.StrictData,-  flagSpec' "TemplateHaskell"                 LangExt.TemplateHaskell-                                              checkTemplateHaskellOk,-  flagSpec "TemplateHaskellQuotes"            LangExt.TemplateHaskellQuotes,-  flagSpec "StandaloneKindSignatures"         LangExt.StandaloneKindSignatures,-  flagSpec "TraditionalRecordSyntax"          LangExt.TraditionalRecordSyntax,-  flagSpec "TransformListComp"                LangExt.TransformListComp,-  flagSpec "TupleSections"                    LangExt.TupleSections,-  flagSpec "TypeApplications"                 LangExt.TypeApplications,-  flagSpec "TypeInType"                       LangExt.TypeInType,-  flagSpec "TypeFamilies"                     LangExt.TypeFamilies,-  flagSpec "TypeOperators"                    LangExt.TypeOperators,-  flagSpec "TypeSynonymInstances"             LangExt.TypeSynonymInstances,-  flagSpec "UnboxedTuples"                    LangExt.UnboxedTuples,-  flagSpec "UnboxedSums"                      LangExt.UnboxedSums,-  flagSpec "UndecidableInstances"             LangExt.UndecidableInstances,-  flagSpec "UndecidableSuperClasses"          LangExt.UndecidableSuperClasses,-  flagSpec "UnicodeSyntax"                    LangExt.UnicodeSyntax,-  flagSpec "UnliftedFFITypes"                 LangExt.UnliftedFFITypes,-  flagSpec "UnliftedNewtypes"                 LangExt.UnliftedNewtypes,-  flagSpec "ViewPatterns"                     LangExt.ViewPatterns-  ]--defaultFlags :: Settings -> [GeneralFlag]-defaultFlags settings--- See Note [Updating flag description in the User's Guide]-  = [ Opt_AutoLinkPackages,-      Opt_DiagnosticsShowCaret,-      Opt_EmbedManifest,-      Opt_FlatCache,-      Opt_GenManifest,-      Opt_GhciHistory,-      Opt_GhciSandbox,-      Opt_HelpfulErrors,-      Opt_KeepHiFiles,-      Opt_KeepOFiles,-      Opt_OmitYields,-      Opt_PrintBindContents,-      Opt_ProfCountEntries,-      Opt_RPath,-      Opt_SharedImplib,-      Opt_SimplPreInlining,-      Opt_VersionMacros-    ]--    ++ [f | (ns,f) <- optLevelFlags, 0 `elem` ns]-             -- The default -O0 options--    ++ default_PIC platform--    ++ concatMap (wayGeneralFlags platform) (defaultWays settings)-    ++ validHoleFitDefaults--    where platform = sTargetPlatform settings---- | These are the default settings for the display and sorting of valid hole---  fits in typed-hole error messages. See Note [Valid hole fits include ...]- -- in the TcHoleErrors module.-validHoleFitDefaults :: [GeneralFlag]-validHoleFitDefaults-  =  [ Opt_ShowTypeAppOfHoleFits-     , Opt_ShowTypeOfHoleFits-     , Opt_ShowProvOfHoleFits-     , Opt_ShowMatchesOfHoleFits-     , Opt_ShowValidHoleFits-     , Opt_SortValidHoleFits-     , Opt_SortBySizeHoleFits-     , Opt_ShowHoleConstraints ]---validHoleFitsImpliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]-validHoleFitsImpliedGFlags-  = [ (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowTypeAppOfHoleFits)-    , (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowTypeAppVarsOfHoleFits)-    , (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowDocsOfHoleFits)-    , (Opt_ShowTypeAppVarsOfHoleFits, turnOff, Opt_ShowTypeAppOfHoleFits)-    , (Opt_UnclutterValidHoleFits, turnOff, Opt_ShowProvOfHoleFits) ]--default_PIC :: Platform -> [GeneralFlag]-default_PIC platform =-  case (platformOS platform, platformArch platform) of-    (OSDarwin, ArchX86_64) -> [Opt_PIC]-    (OSOpenBSD, ArchX86_64) -> [Opt_PIC] -- Due to PIE support in-                                         -- OpenBSD since 5.3 release-                                         -- (1 May 2013) we need to-                                         -- always generate PIC. See-                                         -- #10597 for more-                                         -- information.-    _                      -> []---- General flags that are switched on/off when other general flags are switched--- on-impliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]-impliedGFlags = [(Opt_DeferTypeErrors, turnOn, Opt_DeferTypedHoles)-                ,(Opt_DeferTypeErrors, turnOn, Opt_DeferOutOfScopeVariables)-                ,(Opt_Strictness, turnOn, Opt_WorkerWrapper)-                ] ++ validHoleFitsImpliedGFlags---- General flags that are switched on/off when other general flags are switched--- off-impliedOffGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]-impliedOffGFlags = [(Opt_Strictness, turnOff, Opt_WorkerWrapper)]--impliedXFlags :: [(LangExt.Extension, TurnOnFlag, LangExt.Extension)]-impliedXFlags--- See Note [Updating flag description in the User's Guide]-  = [ (LangExt.RankNTypes,                turnOn, LangExt.ExplicitForAll)-    , (LangExt.QuantifiedConstraints,     turnOn, LangExt.ExplicitForAll)-    , (LangExt.ScopedTypeVariables,       turnOn, LangExt.ExplicitForAll)-    , (LangExt.LiberalTypeSynonyms,       turnOn, LangExt.ExplicitForAll)-    , (LangExt.ExistentialQuantification, turnOn, LangExt.ExplicitForAll)-    , (LangExt.FlexibleInstances,         turnOn, LangExt.TypeSynonymInstances)-    , (LangExt.FunctionalDependencies,    turnOn, LangExt.MultiParamTypeClasses)-    , (LangExt.MultiParamTypeClasses,     turnOn, LangExt.ConstrainedClassMethods)  -- c.f. #7854-    , (LangExt.TypeFamilyDependencies,    turnOn, LangExt.TypeFamilies)--    , (LangExt.RebindableSyntax, turnOff, LangExt.ImplicitPrelude)      -- NB: turn off!--    , (LangExt.DerivingVia, turnOn, LangExt.DerivingStrategies)--    , (LangExt.GADTs,            turnOn, LangExt.GADTSyntax)-    , (LangExt.GADTs,            turnOn, LangExt.MonoLocalBinds)-    , (LangExt.TypeFamilies,     turnOn, LangExt.MonoLocalBinds)--    , (LangExt.TypeFamilies,     turnOn, LangExt.KindSignatures)  -- Type families use kind signatures-    , (LangExt.PolyKinds,        turnOn, LangExt.KindSignatures)  -- Ditto polymorphic kinds--    -- TypeInType is now just a synonym for a couple of other extensions.-    , (LangExt.TypeInType,       turnOn, LangExt.DataKinds)-    , (LangExt.TypeInType,       turnOn, LangExt.PolyKinds)-    , (LangExt.TypeInType,       turnOn, LangExt.KindSignatures)--    -- Standalone kind signatures are a replacement for CUSKs.-    , (LangExt.StandaloneKindSignatures, turnOff, LangExt.CUSKs)--    -- AutoDeriveTypeable is not very useful without DeriveDataTypeable-    , (LangExt.AutoDeriveTypeable, turnOn, LangExt.DeriveDataTypeable)--    -- We turn this on so that we can export associated type-    -- type synonyms in subordinates (e.g. MyClass(type AssocType))-    , (LangExt.TypeFamilies,     turnOn, LangExt.ExplicitNamespaces)-    , (LangExt.TypeOperators, turnOn, LangExt.ExplicitNamespaces)--    , (LangExt.ImpredicativeTypes,  turnOn, LangExt.RankNTypes)--        -- Record wild-cards implies field disambiguation-        -- Otherwise if you write (C {..}) you may well get-        -- stuff like " 'a' not in scope ", which is a bit silly-        -- if the compiler has just filled in field 'a' of constructor 'C'-    , (LangExt.RecordWildCards,     turnOn, LangExt.DisambiguateRecordFields)--    , (LangExt.ParallelArrays, turnOn, LangExt.ParallelListComp)--    , (LangExt.JavaScriptFFI, turnOn, LangExt.InterruptibleFFI)--    , (LangExt.DeriveTraversable, turnOn, LangExt.DeriveFunctor)-    , (LangExt.DeriveTraversable, turnOn, LangExt.DeriveFoldable)--    -- Duplicate record fields require field disambiguation-    , (LangExt.DuplicateRecordFields, turnOn, LangExt.DisambiguateRecordFields)--    , (LangExt.TemplateHaskell, turnOn, LangExt.TemplateHaskellQuotes)-    , (LangExt.Strict, turnOn, LangExt.StrictData)-  ]---- Note [When is StarIsType enabled]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- The StarIsType extension determines whether to treat '*' as a regular type--- operator or as a synonym for 'Data.Kind.Type'. Many existing pre-TypeInType--- programs expect '*' to be synonymous with 'Type', so by default StarIsType is--- enabled.------ Programs that use TypeOperators might expect to repurpose '*' for--- multiplication or another binary operation, but making TypeOperators imply--- NoStarIsType caused too much breakage on Hackage.------- Note [Documenting optimisation flags]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ If you change the list of flags enabled for particular optimisation levels--- please remember to update the User's Guide. The relevant file is:------   docs/users_guide/using-optimisation.rst------ Make sure to note whether a flag is implied by -O0, -O or -O2.--optLevelFlags :: [([Int], GeneralFlag)]-optLevelFlags -- see Note [Documenting optimisation flags]-  = [ ([0,1,2], Opt_DoLambdaEtaExpansion)-    , ([0,1,2], Opt_DoEtaReduction)       -- See Note [Eta-reduction in -O0]-    , ([0,1,2], Opt_DmdTxDictSel)-    , ([0,1,2], Opt_LlvmTBAA)--    , ([0],     Opt_IgnoreInterfacePragmas)-    , ([0],     Opt_OmitInterfacePragmas)--    , ([1,2],   Opt_CallArity)-    , ([1,2],   Opt_Exitification)-    , ([1,2],   Opt_CaseMerge)-    , ([1,2],   Opt_CaseFolding)-    , ([1,2],   Opt_CmmElimCommonBlocks)-    , ([2],     Opt_AsmShortcutting)-    , ([1,2],   Opt_CmmSink)-    , ([1,2],   Opt_CSE)-    , ([1,2],   Opt_StgCSE)-    , ([2],     Opt_StgLiftLams)-    , ([1,2],   Opt_EnableRewriteRules)  -- Off for -O0; see Note [Scoping for Builtin rules]-                                         --              in PrelRules-    , ([1,2],   Opt_FloatIn)-    , ([1,2],   Opt_FullLaziness)-    , ([1,2],   Opt_IgnoreAsserts)-    , ([1,2],   Opt_Loopification)-    , ([1,2],   Opt_CfgBlocklayout)      -- Experimental--    , ([1,2],   Opt_Specialise)-    , ([1,2],   Opt_CrossModuleSpecialise)-    , ([1,2],   Opt_Strictness)-    , ([1,2],   Opt_UnboxSmallStrictFields)-    , ([1,2],   Opt_CprAnal)-    , ([1,2],   Opt_WorkerWrapper)-    , ([1,2],   Opt_SolveConstantDicts)-    , ([1,2],   Opt_NumConstantFolding)--    , ([2],     Opt_LiberateCase)-    , ([2],     Opt_SpecConstr)---  , ([2],     Opt_RegsGraph)---   RegsGraph suffers performance regression. See #7679---  , ([2],     Opt_StaticArgumentTransformation)---   Static Argument Transformation needs investigation. See #9374-    ]--{- Note [Eta-reduction in -O0]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-#11562 showed an example which tripped an ASSERT in CoreToStg; a-function was marked as MayHaveCafRefs when in fact it obviously-didn't.  Reason was:- * Eta reduction wasn't happening in the simplifier, but it was-   happening in CorePrep, on-        $fBla = MkDict (/\a. K a)- * Result: rhsIsStatic told GHC.Iface.Tidy that $fBla might have CAF refs-   but the eta-reduced version (MkDict K) obviously doesn't-Simple solution: just let the simplifier do eta-reduction even in -O0.-After all, CorePrep does it unconditionally!  Not a big deal, but-removes an assertion failure. -}----- -------------------------------------------------------------------------------- Standard sets of warning options---- Note [Documenting warning flags]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ If you change the list of warning enabled by default--- please remember to update the User's Guide. The relevant file is:------  docs/users_guide/using-warnings.rst---- | Warning groups.------ As all warnings are in the Weverything set, it is ignored when--- displaying to the user which group a warning is in.-warningGroups :: [(String, [WarningFlag])]-warningGroups =-    [ ("compat",       minusWcompatOpts)-    , ("unused-binds", unusedBindsFlags)-    , ("default",      standardWarnings)-    , ("extra",        minusWOpts)-    , ("all",          minusWallOpts)-    , ("everything",   minusWeverythingOpts)-    ]---- | Warning group hierarchies, where there is an explicit inclusion--- relation.------ Each inner list is a hierarchy of warning groups, ordered from--- smallest to largest, where each group is a superset of the one--- before it.------ Separating this from 'warningGroups' allows for multiple--- hierarchies with no inherent relation to be defined.------ The special-case Weverything group is not included.-warningHierarchies :: [[String]]-warningHierarchies = hierarchies ++ map (:[]) rest-  where-    hierarchies = [["default", "extra", "all"]]-    rest = filter (`notElem` "everything" : concat hierarchies) $-           map fst warningGroups---- | Find the smallest group in every hierarchy which a warning--- belongs to, excluding Weverything.-smallestGroups :: WarningFlag -> [String]-smallestGroups flag = mapMaybe go warningHierarchies where-    -- Because each hierarchy is arranged from smallest to largest,-    -- the first group we find in a hierarchy which contains the flag-    -- is the smallest.-    go (group:rest) = fromMaybe (go rest) $ do-        flags <- lookup group warningGroups-        guard (flag `elem` flags)-        pure (Just group)-    go [] = Nothing---- | Warnings enabled unless specified otherwise-standardWarnings :: [WarningFlag]-standardWarnings -- see Note [Documenting warning flags]-    = [ Opt_WarnOverlappingPatterns,-        Opt_WarnWarningsDeprecations,-        Opt_WarnDeprecatedFlags,-        Opt_WarnDeferredTypeErrors,-        Opt_WarnTypedHoles,-        Opt_WarnDeferredOutOfScopeVariables,-        Opt_WarnPartialTypeSignatures,-        Opt_WarnUnrecognisedPragmas,-        Opt_WarnDuplicateExports,-        Opt_WarnDerivingDefaults,-        Opt_WarnOverflowedLiterals,-        Opt_WarnEmptyEnumerations,-        Opt_WarnMissingFields,-        Opt_WarnMissingMethods,-        Opt_WarnWrongDoBind,-        Opt_WarnUnsupportedCallingConventions,-        Opt_WarnDodgyForeignImports,-        Opt_WarnInlineRuleShadowing,-        Opt_WarnAlternativeLayoutRuleTransitional,-        Opt_WarnUnsupportedLlvmVersion,-        Opt_WarnMissedExtraSharedLib,-        Opt_WarnTabs,-        Opt_WarnUnrecognisedWarningFlags,-        Opt_WarnSimplifiableClassConstraints,-        Opt_WarnStarBinder,-        Opt_WarnInaccessibleCode,-        Opt_WarnSpaceAfterBang-      ]---- | Things you get with -W-minusWOpts :: [WarningFlag]-minusWOpts-    = standardWarnings ++-      [ Opt_WarnUnusedTopBinds,-        Opt_WarnUnusedLocalBinds,-        Opt_WarnUnusedPatternBinds,-        Opt_WarnUnusedMatches,-        Opt_WarnUnusedForalls,-        Opt_WarnUnusedImports,-        Opt_WarnIncompletePatterns,-        Opt_WarnDodgyExports,-        Opt_WarnDodgyImports,-        Opt_WarnUnbangedStrictPatterns-      ]---- | Things you get with -Wall-minusWallOpts :: [WarningFlag]-minusWallOpts-    = minusWOpts ++-      [ Opt_WarnTypeDefaults,-        Opt_WarnNameShadowing,-        Opt_WarnMissingSignatures,-        Opt_WarnHiShadows,-        Opt_WarnOrphans,-        Opt_WarnUnusedDoBind,-        Opt_WarnTrustworthySafe,-        Opt_WarnUntickedPromotedConstructors,-        Opt_WarnMissingPatternSynonymSignatures,-        Opt_WarnUnusedRecordWildcards,-        Opt_WarnRedundantRecordWildcards-      ]---- | Things you get with -Weverything, i.e. *all* known warnings flags-minusWeverythingOpts :: [WarningFlag]-minusWeverythingOpts = [ toEnum 0 .. ]---- | Things you get with -Wcompat.------ This is intended to group together warnings that will be enabled by default--- at some point in the future, so that library authors eager to make their--- code future compatible to fix issues before they even generate warnings.-minusWcompatOpts :: [WarningFlag]-minusWcompatOpts-    = [ Opt_WarnMissingMonadFailInstances-      , Opt_WarnSemigroup-      , Opt_WarnNonCanonicalMonoidInstances-      , Opt_WarnStarIsType-      ]--enableUnusedBinds :: DynP ()-enableUnusedBinds = mapM_ setWarningFlag unusedBindsFlags--disableUnusedBinds :: DynP ()-disableUnusedBinds = mapM_ unSetWarningFlag unusedBindsFlags---- Things you get with -Wunused-binds-unusedBindsFlags :: [WarningFlag]-unusedBindsFlags = [ Opt_WarnUnusedTopBinds-                   , Opt_WarnUnusedLocalBinds-                   , Opt_WarnUnusedPatternBinds-                   ]--enableGlasgowExts :: DynP ()-enableGlasgowExts = do setGeneralFlag Opt_PrintExplicitForalls-                       mapM_ setExtensionFlag glasgowExtsFlags--disableGlasgowExts :: DynP ()-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-           , LangExt.DeriveDataTypeable-           , LangExt.DeriveFoldable-           , LangExt.DeriveFunctor-           , LangExt.DeriveGeneric-           , LangExt.DeriveTraversable-           , LangExt.EmptyDataDecls-           , LangExt.ExistentialQuantification-           , LangExt.ExplicitNamespaces-           , LangExt.FlexibleContexts-           , LangExt.FlexibleInstances-           , LangExt.ForeignFunctionInterface-           , LangExt.FunctionalDependencies-           , LangExt.GeneralizedNewtypeDeriving-           , LangExt.ImplicitParams-           , LangExt.KindSignatures-           , LangExt.LiberalTypeSynonyms-           , LangExt.MagicHash-           , LangExt.MultiParamTypeClasses-           , LangExt.ParallelListComp-           , LangExt.PatternGuards-           , LangExt.PostfixOperators-           , LangExt.RankNTypes-           , LangExt.RecursiveDo-           , LangExt.ScopedTypeVariables-           , LangExt.StandaloneDeriving-           , LangExt.TypeOperators-           , LangExt.TypeSynonymInstances-           , LangExt.UnboxedTuples-           , LangExt.UnicodeSyntax-           , LangExt.UnliftedFFITypes ]--foreign import ccall unsafe "rts_isProfiled" rtsIsProfiledIO :: IO CInt---- | Was the runtime system built with profiling enabled?-rtsIsProfiled :: Bool-rtsIsProfiled = unsafeDupablePerformIO rtsIsProfiledIO /= 0---- Consult the RTS to find whether GHC itself has been built with--- dynamic linking.  This can't be statically known at compile-time,--- because we build both the static and dynamic versions together with--- -dynamic-too.-foreign import ccall unsafe "rts_isDynamic" rtsIsDynamicIO :: IO CInt--dynamicGhc :: Bool-dynamicGhc = unsafeDupablePerformIO rtsIsDynamicIO /= 0--setWarnSafe :: Bool -> DynP ()-setWarnSafe True  = getCurLoc >>= \l -> upd (\d -> d { warnSafeOnLoc = l })-setWarnSafe False = return ()--setWarnUnsafe :: Bool -> DynP ()-setWarnUnsafe True  = getCurLoc >>= \l -> upd (\d -> d { warnUnsafeOnLoc = l })-setWarnUnsafe False = return ()--setPackageTrust :: DynP ()-setPackageTrust = do-    setGeneralFlag Opt_PackageTrust-    l <- getCurLoc-    upd $ \d -> d { pkgTrustOnLoc = l }--setGenDeriving :: TurnOnFlag -> DynP ()-setGenDeriving True  = getCurLoc >>= \l -> upd (\d -> d { newDerivOnLoc = l })-setGenDeriving False = return ()--setOverlappingInsts :: TurnOnFlag -> DynP ()-setOverlappingInsts False = return ()-setOverlappingInsts True = do-  l <- getCurLoc-  upd (\d -> d { overlapInstLoc = l })--setIncoherentInsts :: TurnOnFlag -> DynP ()-setIncoherentInsts False = return ()-setIncoherentInsts True = do-  l <- getCurLoc-  upd (\d -> d { incoherentOnLoc = l })--checkTemplateHaskellOk :: TurnOnFlag -> DynP ()-checkTemplateHaskellOk _turn_on-  = getCurLoc >>= \l -> upd (\d -> d { thOnLoc = l })--{- **********************************************************************-%*                                                                      *-                DynFlags constructors-%*                                                                      *-%********************************************************************* -}--type DynP = EwM (CmdLineP DynFlags)--upd :: (DynFlags -> DynFlags) -> DynP ()-upd f = liftEwM (do dflags <- getCmdLineState-                    putCmdLineState $! f dflags)--updM :: (DynFlags -> DynP DynFlags) -> DynP ()-updM f = do dflags <- liftEwM getCmdLineState-            dflags' <- f dflags-            liftEwM $ putCmdLineState $! dflags'----------------- Constructor functions for OptKind ------------------noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)-noArg fn = NoArg (upd fn)--noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)-noArgM fn = NoArg (updM fn)--hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)-hasArg fn = HasArg (upd . fn)--sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)-sepArg fn = SepArg (upd . fn)--intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)-intSuffix fn = IntSuffix (\n -> upd (fn n))--intSuffixM :: (Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)-intSuffixM fn = IntSuffix (\n -> updM (fn n))--floatSuffix :: (Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)-floatSuffix fn = FloatSuffix (\n -> upd (fn n))--optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)-              -> OptKind (CmdLineP DynFlags)-optIntSuffixM fn = OptIntSuffix (\mi -> updM (fn mi))--setDumpFlag :: DumpFlag -> OptKind (CmdLineP DynFlags)-setDumpFlag dump_flag = NoArg (setDumpFlag' dump_flag)-----------------------------addWay :: Way -> DynP ()-addWay w = upd (addWay' w)--addWay' :: Way -> DynFlags -> DynFlags-addWay' w dflags0 = let platform = targetPlatform dflags0-                        dflags1 = dflags0 { ways = w : ways dflags0 }-                        dflags2 = foldr setGeneralFlag' dflags1-                                        (wayGeneralFlags platform w)-                        dflags3 = foldr unSetGeneralFlag' dflags2-                                        (wayUnsetGeneralFlags platform w)-                    in dflags3--removeWayDyn :: DynP ()-removeWayDyn = upd (\dfs -> dfs { ways = filter (WayDyn /=) (ways dfs) })-----------------------------setGeneralFlag, unSetGeneralFlag :: GeneralFlag -> DynP ()-setGeneralFlag   f = upd (setGeneralFlag' f)-unSetGeneralFlag f = upd (unSetGeneralFlag' f)--setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags-setGeneralFlag' f dflags = foldr ($) (gopt_set dflags f) deps-  where-    deps = [ if turn_on then setGeneralFlag'   d-                        else unSetGeneralFlag' d-           | (f', turn_on, d) <- impliedGFlags, f' == f ]-        -- When you set f, set the ones it implies-        -- NB: use setGeneralFlag recursively, in case the implied flags-        --     implies further flags--unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags-unSetGeneralFlag' f dflags = foldr ($) (gopt_unset dflags f) deps-  where-    deps = [ if turn_on then setGeneralFlag' d-                        else unSetGeneralFlag' d-           | (f', turn_on, d) <- impliedOffGFlags, f' == f ]-   -- In general, when you un-set f, we don't un-set the things it implies.-   -- There are however some exceptions, e.g., -fno-strictness implies-   -- -fno-worker-wrapper.-   ---   -- NB: use unSetGeneralFlag' recursively, in case the implied off flags-   --     imply further flags.-----------------------------setWarningFlag, unSetWarningFlag :: WarningFlag -> DynP ()-setWarningFlag   f = upd (\dfs -> wopt_set dfs f)-unSetWarningFlag f = upd (\dfs -> wopt_unset dfs f)--setFatalWarningFlag, unSetFatalWarningFlag :: WarningFlag -> DynP ()-setFatalWarningFlag   f = upd (\dfs -> wopt_set_fatal dfs f)-unSetFatalWarningFlag f = upd (\dfs -> wopt_unset_fatal dfs f)--setWErrorFlag :: WarningFlag -> DynP ()-setWErrorFlag flag =-  do { setWarningFlag flag-     ; setFatalWarningFlag flag }-----------------------------setExtensionFlag, unSetExtensionFlag :: LangExt.Extension -> DynP ()-setExtensionFlag f = upd (setExtensionFlag' f)-unSetExtensionFlag f = upd (unSetExtensionFlag' f)--setExtensionFlag', unSetExtensionFlag' :: LangExt.Extension -> DynFlags -> DynFlags-setExtensionFlag' f dflags = foldr ($) (xopt_set dflags f) deps-  where-    deps = [ if turn_on then setExtensionFlag'   d-                        else unSetExtensionFlag' d-           | (f', turn_on, d) <- impliedXFlags, f' == f ]-        -- When you set f, set the ones it implies-        -- NB: use setExtensionFlag recursively, in case the implied flags-        --     implies further flags--unSetExtensionFlag' f dflags = xopt_unset dflags f-   -- When you un-set f, however, we don't un-set the things it implies-   --      (except for -fno-glasgow-exts, which is treated specially)-----------------------------alterFileSettings :: (FileSettings -> FileSettings) -> DynFlags -> DynFlags-alterFileSettings f dynFlags = dynFlags { fileSettings = f (fileSettings dynFlags) }--alterToolSettings :: (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags-alterToolSettings f dynFlags = dynFlags { toolSettings = f (toolSettings dynFlags) }-----------------------------setDumpFlag' :: DumpFlag -> DynP ()-setDumpFlag' dump_flag-  = do upd (\dfs -> dopt_set dfs dump_flag)-       when want_recomp forceRecompile-    where -- Certain dumpy-things are really interested in what's going-          -- on during recompilation checking, so in those cases we-          -- don't want to turn it off.-          want_recomp = dump_flag `notElem` [Opt_D_dump_if_trace,-                                             Opt_D_dump_hi_diffs,-                                             Opt_D_no_debug_output]--forceRecompile :: DynP ()--- Whenever we -ddump, force recompilation (by switching off the--- recompilation checker), else you don't see the dump! However,--- don't switch it off in --make mode, else *everything* gets--- recompiled which probably isn't what you want-forceRecompile = do dfs <- liftEwM getCmdLineState-                    when (force_recomp dfs) (setGeneralFlag Opt_ForceRecomp)-        where-          force_recomp dfs = isOneShot (ghcMode dfs)---setVerboseCore2Core :: DynP ()-setVerboseCore2Core = setDumpFlag' Opt_D_verbose_core2core--setVerbosity :: Maybe Int -> DynP ()-setVerbosity mb_n = upd (\dfs -> dfs{ verbosity = mb_n `orElse` 3 })--setDebugLevel :: Maybe Int -> DynP ()-setDebugLevel mb_n = upd (\dfs -> dfs{ debugLevel = mb_n `orElse` 2 })--data PkgDbRef-  = GlobalPkgDb-  | UserPkgDb-  | PkgDbPath FilePath-  deriving Eq--addPkgDbRef :: PkgDbRef -> DynP ()-addPkgDbRef p = upd $ \s ->-  s { packageDBFlags = PackageDB p : packageDBFlags s }--removeUserPkgDb :: DynP ()-removeUserPkgDb = upd $ \s ->-  s { packageDBFlags = NoUserPackageDB : packageDBFlags s }--removeGlobalPkgDb :: DynP ()-removeGlobalPkgDb = upd $ \s ->- s { packageDBFlags = NoGlobalPackageDB : packageDBFlags s }--clearPkgDb :: DynP ()-clearPkgDb = upd $ \s ->-  s { packageDBFlags = ClearPackageDBs : packageDBFlags s }--parsePackageFlag :: String                 -- the flag-                 -> ReadP PackageArg       -- type of argument-                 -> String                 -- string to parse-                 -> PackageFlag-parsePackageFlag flag arg_parse str- = case filter ((=="").snd) (readP_to_S parse str) of-    [(r, "")] -> r-    _ -> throwGhcException $ CmdLineError ("Can't parse package flag: " ++ str)-  where doc = flag ++ " " ++ str-        parse = do-            pkg_arg <- tok arg_parse-            let mk_expose = ExposePackage doc pkg_arg-            ( do _ <- tok $ string "with"-                 fmap (mk_expose . ModRenaming True) parseRns-             <++ fmap (mk_expose . ModRenaming False) parseRns-             <++ return (mk_expose (ModRenaming True [])))-        parseRns = do _ <- tok $ R.char '('-                      rns <- tok $ sepBy parseItem (tok $ R.char ',')-                      _ <- tok $ R.char ')'-                      return rns-        parseItem = do-            orig <- tok $ parseModuleName-            (do _ <- tok $ string "as"-                new <- tok $ parseModuleName-                return (orig, new)-              +++-             return (orig, orig))-        tok m = m >>= \x -> skipSpaces >> return x--exposePackage, exposePackageId, hidePackage,-        exposePluginPackage, exposePluginPackageId,-        ignorePackage,-        trustPackage, distrustPackage :: String -> DynP ()-exposePackage p = upd (exposePackage' p)-exposePackageId p =-  upd (\s -> s{ packageFlags =-    parsePackageFlag "-package-id" parseUnitIdArg p : packageFlags s })-exposePluginPackage p =-  upd (\s -> s{ pluginPackageFlags =-    parsePackageFlag "-plugin-package" parsePackageArg p : pluginPackageFlags s })-exposePluginPackageId p =-  upd (\s -> s{ pluginPackageFlags =-    parsePackageFlag "-plugin-package-id" parseUnitIdArg p : pluginPackageFlags s })-hidePackage p =-  upd (\s -> s{ packageFlags = HidePackage p : packageFlags s })-ignorePackage p =-  upd (\s -> s{ ignorePackageFlags = IgnorePackage p : ignorePackageFlags s })--trustPackage p = exposePackage p >> -- both trust and distrust also expose a package-  upd (\s -> s{ trustFlags = TrustPackage p : trustFlags s })-distrustPackage p = exposePackage p >>-  upd (\s -> s{ trustFlags = DistrustPackage p : trustFlags s })--exposePackage' :: String -> DynFlags -> DynFlags-exposePackage' p dflags-    = dflags { packageFlags =-            parsePackageFlag "-package" parsePackageArg p : packageFlags dflags }--parsePackageArg :: ReadP PackageArg-parsePackageArg =-    fmap PackageArg (munch1 (\c -> isAlphaNum c || c `elem` ":-_."))--parseUnitIdArg :: ReadP PackageArg-parseUnitIdArg =-    fmap UnitIdArg parseUnitId--setUnitId :: String -> DynFlags -> DynFlags-setUnitId p d = d { thisInstalledUnitId = stringToInstalledUnitId p }---- | Given a 'ModuleName' of a signature in the home library, find--- out how it is instantiated.  E.g., the canonical form of--- A in @p[A=q[]:A]@ is @q[]:A@.-canonicalizeHomeModule :: DynFlags -> ModuleName -> Module-canonicalizeHomeModule dflags mod_name =-    case lookup mod_name (thisUnitIdInsts dflags) of-        Nothing  -> mkModule (thisPackage dflags) mod_name-        Just mod -> mod--canonicalizeModuleIfHome :: DynFlags -> Module -> Module-canonicalizeModuleIfHome dflags mod-    = if thisPackage dflags == moduleUnitId mod-                      then canonicalizeHomeModule dflags (moduleName mod)-                      else mod---- If we're linking a binary, then only targets that produce object--- code are allowed (requests for other target types are ignored).-setTarget :: HscTarget -> DynP ()-setTarget l = upd $ \ dfs ->-  if ghcLink dfs /= LinkBinary || isObjectTarget l-  then dfs{ hscTarget = l }-  else dfs---- Changes the target only if we're compiling object code.  This is--- used by -fasm and -fllvm, which switch from one to the other, but--- not from bytecode to object-code.  The idea is that -fasm/-fllvm--- can be safely used in an OPTIONS_GHC pragma.-setObjTarget :: HscTarget -> DynP ()-setObjTarget l = updM set-  where-   set dflags-     | isObjectTarget (hscTarget dflags)-       = return $ dflags { hscTarget = l }-     | otherwise = return dflags--setOptLevel :: Int -> DynFlags -> DynP DynFlags-setOptLevel n dflags = return (updOptLevel n dflags)--checkOptLevel :: Int -> DynFlags -> Either String DynFlags-checkOptLevel n dflags-   | hscTarget dflags == HscInterpreted && n > 0-     = Left "-O conflicts with --interactive; -O ignored."-   | otherwise-     = Right dflags--setMainIs :: String -> DynP ()-setMainIs arg-  | not (null main_fn) && isLower (head main_fn)-     -- The arg looked like "Foo.Bar.baz"-  = upd $ \d -> d { mainFunIs = Just main_fn,-                   mainModIs = mkModule mainUnitId (mkModuleName main_mod) }--  | isUpper (head arg)  -- The arg looked like "Foo" or "Foo.Bar"-  = upd $ \d -> d { mainModIs = mkModule mainUnitId (mkModuleName arg) }--  | otherwise                   -- The arg looked like "baz"-  = upd $ \d -> d { mainFunIs = Just arg }-  where-    (main_mod, main_fn) = splitLongestPrefix arg (== '.')--addLdInputs :: Option -> DynFlags -> DynFlags-addLdInputs p dflags = dflags{ldInputs = ldInputs dflags ++ [p]}---- -------------------------------------------------------------------------------- Load dynflags from environment files.--setFlagsFromEnvFile :: FilePath -> String -> DynP ()-setFlagsFromEnvFile envfile content = do-  setGeneralFlag Opt_HideAllPackages-  parseEnvFile envfile content--parseEnvFile :: FilePath -> String -> DynP ()-parseEnvFile envfile = mapM_ parseEntry . lines-  where-    parseEntry str = case words str of-      ("package-db": _)     -> addPkgDbRef (PkgDbPath (envdir </> db))-        -- relative package dbs are interpreted relative to the env file-        where envdir = takeDirectory envfile-              db     = drop 11 str-      ["clear-package-db"]  -> clearPkgDb-      ["global-package-db"] -> addPkgDbRef GlobalPkgDb-      ["user-package-db"]   -> addPkgDbRef UserPkgDb-      ["package-id", pkgid] -> exposePackageId pkgid-      (('-':'-':_):_)       -> return () -- comments-      -- and the original syntax introduced in 7.10:-      [pkgid]               -> exposePackageId pkgid-      []                    -> return ()-      _                     -> throwGhcException $ CmdLineError $-                                    "Can't parse environment file entry: "-                                 ++ envfile ++ ": " ++ str----------------------------------------------------------------------------------- Paths & Libraries--addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()---- -i on its own deletes the import paths-addImportPath "" = upd (\s -> s{importPaths = []})-addImportPath p  = upd (\s -> s{importPaths = importPaths s ++ splitPathList p})--addLibraryPath p =-  upd (\s -> s{libraryPaths = libraryPaths s ++ splitPathList p})--addIncludePath p =-  upd (\s -> s{includePaths =-                  addGlobalInclude (includePaths s) (splitPathList p)})--addFrameworkPath p =-  upd (\s -> s{frameworkPaths = frameworkPaths s ++ splitPathList p})--#if !defined(mingw32_HOST_OS)-split_marker :: Char-split_marker = ':'   -- not configurable (ToDo)-#endif--splitPathList :: String -> [String]-splitPathList s = filter notNull (splitUp s)-                -- empty paths are ignored: there might be a trailing-                -- ':' in the initial list, for example.  Empty paths can-                -- cause confusion when they are translated into -I options-                -- for passing to gcc.-  where-#if !defined(mingw32_HOST_OS)-    splitUp xs = split split_marker xs-#else-     -- Windows: 'hybrid' support for DOS-style paths in directory lists.-     ---     -- That is, if "foo:bar:baz" is used, this interpreted as-     -- consisting of three entries, 'foo', 'bar', 'baz'.-     -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted-     -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"-     ---     -- Notice that no attempt is made to fully replace the 'standard'-     -- split marker ':' with the Windows / DOS one, ';'. The reason being-     -- that this will cause too much breakage for users & ':' will-     -- work fine even with DOS paths, if you're not insisting on being silly.-     -- So, use either.-    splitUp []             = []-    splitUp (x:':':div:xs) | div `elem` dir_markers-                           = ((x:':':div:p): splitUp rs)-                           where-                              (p,rs) = findNextPath xs-          -- we used to check for existence of the path here, but that-          -- required the IO monad to be threaded through the command-line-          -- parser which is quite inconvenient.  The-    splitUp xs = cons p (splitUp rs)-               where-                 (p,rs) = findNextPath xs--                 cons "" xs = xs-                 cons x  xs = x:xs--    -- will be called either when we've consumed nought or the-    -- "<Drive>:/" part of a DOS path, so splitting is just a Q of-    -- finding the next split marker.-    findNextPath xs =-        case break (`elem` split_markers) xs of-           (p, _:ds) -> (p, ds)-           (p, xs)   -> (p, xs)--    split_markers :: [Char]-    split_markers = [':', ';']--    dir_markers :: [Char]-    dir_markers = ['/', '\\']-#endif---- -------------------------------------------------------------------------------- tmpDir, where we store temporary files.--setTmpDir :: FilePath -> DynFlags -> DynFlags-setTmpDir dir = alterFileSettings $ \s -> s { fileSettings_tmpDir = normalise dir }-  -- we used to fix /cygdrive/c/.. on Windows, but this doesn't-  -- seem necessary now --SDM 7/2/2008---------------------------------------------------------------------------------- RTS opts--setRtsOpts :: String -> DynP ()-setRtsOpts arg  = upd $ \ d -> d {rtsOpts = Just arg}--setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()-setRtsOptsEnabled arg  = upd $ \ d -> d {rtsOptsEnabled = arg}---------------------------------------------------------------------------------- Hpc stuff--setOptHpcDir :: String -> DynP ()-setOptHpcDir arg  = upd $ \ d -> d {hpcDir = arg}---------------------------------------------------------------------------------- Via-C compilation stuff---- There are some options that we need to pass to gcc when compiling--- Haskell code via C, but are only supported by recent versions of--- gcc.  The configure script decides which of these options we need,--- and puts them in the "settings" file in $topdir. The advantage of--- having these in a separate file is that the file can be created at--- install-time depending on the available gcc version, and even--- re-generated later if gcc is upgraded.------ The options below are not dependent on the version of gcc, only the--- platform.--picCCOpts :: DynFlags -> [String]-picCCOpts dflags = pieOpts ++ picOpts-  where-    picOpts =-      case platformOS (targetPlatform dflags) of-      OSDarwin-          -- Apple prefers to do things the other way round.-          -- PIC is on by default.-          -- -mdynamic-no-pic:-          --     Turn off PIC code generation.-          -- -fno-common:-          --     Don't generate "common" symbols - these are unwanted-          --     in dynamic libraries.--       | gopt Opt_PIC dflags -> ["-fno-common", "-U__PIC__", "-D__PIC__"]-       | otherwise           -> ["-mdynamic-no-pic"]-      OSMinGW32 -- no -fPIC for Windows-       | gopt Opt_PIC dflags -> ["-U__PIC__", "-D__PIC__"]-       | otherwise           -> []-      _-      -- we need -fPIC for C files when we are compiling with -dynamic,-      -- otherwise things like stub.c files don't get compiled-      -- correctly.  They need to reference data in the Haskell-      -- objects, but can't without -fPIC.  See-      -- https://gitlab.haskell.org/ghc/ghc/wikis/commentary/position-independent-code-       | gopt Opt_PIC dflags || WayDyn `elem` ways dflags ->-          ["-fPIC", "-U__PIC__", "-D__PIC__"]-      -- gcc may be configured to have PIC on by default, let's be-      -- explicit here, see #15847-       | otherwise -> ["-fno-PIC"]--    pieOpts-      | gopt Opt_PICExecutable dflags       = ["-pie"]-        -- See Note [No PIE when linking]-      | toolSettings_ccSupportsNoPie (toolSettings dflags) = ["-no-pie"]-      | otherwise                           = []---{--Note [No PIE while linking]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-As of 2016 some Linux distributions (e.g. Debian) have started enabling -pie by-default in their gcc builds. This is incompatible with -r as it implies that we-are producing an executable. Consequently, we must manually pass -no-pie to gcc-when joining object files or linking dynamic libraries. Unless, of course, the-user has explicitly requested a PIE executable with -pie. See #12759.--}--picPOpts :: DynFlags -> [String]-picPOpts dflags- | gopt Opt_PIC dflags = ["-U__PIC__", "-D__PIC__"]- | otherwise           = []---- -------------------------------------------------------------------------------- Compiler Info--compilerInfo :: DynFlags -> [(String, String)]-compilerInfo dflags-    = -- We always make "Project name" be first to keep parsing in-      -- other languages simple, i.e. when looking for other fields,-      -- you don't have to worry whether there is a leading '[' or not-      ("Project name",                 cProjectName)-      -- Next come the settings, so anything else can be overridden-      -- in the settings file (as "lookup" uses the first match for the-      -- key)-    : map (fmap $ expandDirectories (topDir dflags) (toolDir dflags))-          (rawSettings dflags)-   ++ [("Project version",             projectVersion dflags),-       ("Project Git commit id",       cProjectGitCommitId),-       ("Booter version",              cBooterVersion),-       ("Stage",                       cStage),-       ("Build platform",              cBuildPlatformString),-       ("Host platform",               cHostPlatformString),-       ("Target platform",             platformMisc_targetPlatformString $ platformMisc dflags),-       ("Have interpreter",            showBool $ platformMisc_ghcWithInterpreter $ platformMisc dflags),-       ("Object splitting supported",  showBool False),-       ("Have native code generator",  showBool $ platformMisc_ghcWithNativeCodeGen $ platformMisc dflags),-       -- Whether or not we support @-dynamic-too@-       ("Support dynamic-too",         showBool $ not isWindows),-       -- Whether or not we support the @-j@ flag with @--make@.-       ("Support parallel --make",     "YES"),-       -- Whether or not we support "Foo from foo-0.1-XXX:Foo" syntax in-       -- installed package info.-       ("Support reexported-modules",  "YES"),-       -- Whether or not we support extended @-package foo (Foo)@ syntax.-       ("Support thinning and renaming package flags", "YES"),-       -- Whether or not we support Backpack.-       ("Support Backpack", "YES"),-       -- If true, we require that the 'id' field in installed package info-       -- match what is passed to the @-this-unit-id@ flag for modules-       -- built in it-       ("Requires unified installed package IDs", "YES"),-       -- Whether or not we support the @-this-package-key@ flag.  Prefer-       -- "Uses unit IDs" over it.-       ("Uses package keys",           "YES"),-       -- Whether or not we support the @-this-unit-id@ flag-       ("Uses unit IDs",               "YES"),-       -- Whether or not GHC compiles libraries as dynamic by default-       ("Dynamic by default",          showBool $ dYNAMIC_BY_DEFAULT dflags),-       -- Whether or not GHC was compiled using -dynamic-       ("GHC Dynamic",                 showBool dynamicGhc),-       -- Whether or not GHC was compiled using -prof-       ("GHC Profiled",                showBool rtsIsProfiled),-       ("Debug on",                    showBool debugIsOn),-       ("LibDir",                      topDir dflags),-       -- The path of the global package database used by GHC-       ("Global Package DB",           globalPackageDatabasePath dflags)-      ]-  where-    showBool True  = "YES"-    showBool False = "NO"-    isWindows = platformOS (targetPlatform dflags) == OSMinGW32-    expandDirectories :: FilePath -> Maybe FilePath -> String -> String-    expandDirectories topd mtoold = expandToolDir mtoold . expandTopDir topd---- Produced by deriveConstants-#include "GHCConstantsHaskellWrappers.hs"--bLOCK_SIZE_W :: DynFlags -> Int-bLOCK_SIZE_W dflags = bLOCK_SIZE dflags `quot` wORD_SIZE dflags--wORD_SIZE_IN_BITS :: DynFlags -> Int-wORD_SIZE_IN_BITS dflags = wORD_SIZE dflags * 8--wordAlignment :: DynFlags -> Alignment-wordAlignment dflags = alignmentOf (wORD_SIZE dflags)--tAG_MASK :: DynFlags -> Int-tAG_MASK dflags = (1 `shiftL` tAG_BITS dflags) - 1--mAX_PTR_TAG :: DynFlags -> Int-mAX_PTR_TAG = tAG_MASK---- Might be worth caching these in targetPlatform?-tARGET_MIN_INT, tARGET_MAX_INT, tARGET_MAX_WORD :: DynFlags -> Integer-tARGET_MIN_INT dflags-    = case platformWordSize (targetPlatform dflags) of-      PW4 -> toInteger (minBound :: Int32)-      PW8 -> toInteger (minBound :: Int64)-tARGET_MAX_INT dflags-    = case platformWordSize (targetPlatform dflags) of-      PW4 -> toInteger (maxBound :: Int32)-      PW8 -> toInteger (maxBound :: Int64)-tARGET_MAX_WORD dflags-    = case platformWordSize (targetPlatform dflags) of-      PW4 -> toInteger (maxBound :: Word32)-      PW8 -> toInteger (maxBound :: Word64)---{- ------------------------------------------------------------------------------Note [DynFlags consistency]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~--There are a number of number of DynFlags configurations which either-do not make sense or lead to unimplemented or buggy codepaths in the-compiler. makeDynFlagsConsistent is responsible for verifying the validity-of a set of DynFlags, fixing any issues, and reporting them back to the-caller.--GHCi and -O------------------When using optimization, the compiler can introduce several things-(such as unboxed tuples) into the intermediate code, which GHCi later-chokes on since the bytecode interpreter can't handle this (and while-this is arguably a bug these aren't handled, there are no plans to fix-it.)--While the driver pipeline always checks for this particular erroneous-combination when parsing flags, we also need to check when we update-the flags; this is because API clients may parse flags but update the-DynFlags afterwords, before finally running code inside a session (see-T10052 and #10052).--}---- | Resolve any internal inconsistencies in a set of 'DynFlags'.--- Returns the consistent 'DynFlags' as well as a list of warnings--- to report to the user.-makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])--- Whenever makeDynFlagsConsistent does anything, it starts over, to--- ensure that a later change doesn't invalidate an earlier check.--- Be careful not to introduce potential loops!-makeDynFlagsConsistent dflags- -- Disable -dynamic-too on Windows (#8228, #7134, #5987)- | os == OSMinGW32 && gopt Opt_BuildDynamicToo dflags-    = let dflags' = gopt_unset dflags Opt_BuildDynamicToo-          warn    = "-dynamic-too is not supported on Windows"-      in loop dflags' warn- | hscTarget dflags == HscC &&-   not (platformUnregisterised (targetPlatform dflags))-    = if platformMisc_ghcWithNativeCodeGen $ platformMisc dflags-      then let dflags' = dflags { hscTarget = HscAsm }-               warn = "Compiler not unregisterised, so using native code generator rather than compiling via C"-           in loop dflags' warn-      else let dflags' = dflags { hscTarget = HscLlvm }-               warn = "Compiler not unregisterised, so using LLVM rather than compiling via C"-           in loop dflags' warn- | gopt Opt_Hpc dflags && hscTarget dflags == HscInterpreted-    = let dflags' = gopt_unset dflags Opt_Hpc-          warn = "Hpc can't be used with byte-code interpreter. Ignoring -fhpc."-      in loop dflags' warn- | hscTarget dflags `elem` [HscAsm, HscLlvm] &&-   platformUnregisterised (targetPlatform dflags)-    = loop (dflags { hscTarget = HscC })-           "Compiler unregisterised, so compiling via C"- | hscTarget dflags == HscAsm &&-   not (platformMisc_ghcWithNativeCodeGen $ platformMisc dflags)-      = let dflags' = dflags { hscTarget = HscLlvm }-            warn = "No native code generator, so using LLVM"-        in loop dflags' warn- | not (osElfTarget os) && gopt Opt_PIE dflags-    = loop (gopt_unset dflags Opt_PIE)-           "Position-independent only supported on ELF platforms"- | os == OSDarwin &&-   arch == ArchX86_64 &&-   not (gopt Opt_PIC dflags)-    = loop (gopt_set dflags Opt_PIC)-           "Enabling -fPIC as it is always on for this platform"- | Left err <- checkOptLevel (optLevel dflags) dflags-    = loop (updOptLevel 0 dflags) err-- | LinkInMemory <- ghcLink dflags- , not (gopt Opt_ExternalInterpreter dflags)- , rtsIsProfiled- , isObjectTarget (hscTarget dflags)- , WayProf `notElem` ways dflags-    = loop dflags{ways = WayProf : ways dflags}-         "Enabling -prof, because -fobject-code is enabled and GHCi is profiled"-- | otherwise = (dflags, [])-    where loc = mkGeneralSrcSpan (fsLit "when making flags consistent")-          loop updated_dflags warning-              = case makeDynFlagsConsistent updated_dflags of-                (dflags', ws) -> (dflags', L loc warning : ws)-          platform = targetPlatform dflags-          arch = platformArch platform-          os   = platformOS   platform-------------------------------------------------------------------------------- Do not use unsafeGlobalDynFlags!------ unsafeGlobalDynFlags is a hack, necessary because we need to be able--- to show SDocs when tracing, but we don't always have DynFlags--- available.------ Do not use it if you can help it. You may get the wrong value, or this--- panic!---- | This is the value that 'unsafeGlobalDynFlags' takes before it is--- initialized.-defaultGlobalDynFlags :: DynFlags-defaultGlobalDynFlags =-    (defaultDynFlags settings llvmConfig) { verbosity = 2 }-  where-    settings = panic "v_unsafeGlobalDynFlags: settings not initialised"-    llvmConfig = panic "v_unsafeGlobalDynFlags: llvmConfig not initialised"--#if GHC_STAGE < 2-GLOBAL_VAR(v_unsafeGlobalDynFlags, defaultGlobalDynFlags, DynFlags)-#else-SHARED_GLOBAL_VAR( v_unsafeGlobalDynFlags-                 , getOrSetLibHSghcGlobalDynFlags-                 , "getOrSetLibHSghcGlobalDynFlags"-                 , defaultGlobalDynFlags-                 , DynFlags )-#endif--unsafeGlobalDynFlags :: DynFlags-unsafeGlobalDynFlags = unsafePerformIO $ readIORef v_unsafeGlobalDynFlags--setUnsafeGlobalDynFlags :: DynFlags -> IO ()-setUnsafeGlobalDynFlags = writeIORef v_unsafeGlobalDynFlags---- -------------------------------------------------------------------------------- SSE and AVX---- TODO: Instead of using a separate predicate (i.e. isSse2Enabled) to--- check if SSE is enabled, we might have x86-64 imply the -msse2--- flag.--data SseVersion = SSE1-                | SSE2-                | SSE3-                | SSE4-                | SSE42-                deriving (Eq, Ord)--isSseEnabled :: DynFlags -> Bool-isSseEnabled dflags = case platformArch (targetPlatform dflags) of-    ArchX86_64 -> True-    ArchX86    -> True-    _          -> False--isSse2Enabled :: DynFlags -> Bool-isSse2Enabled dflags = case platformArch (targetPlatform dflags) of-  -- We Assume  SSE1 and SSE2 operations are available on both-  -- x86 and x86_64. Historically we didn't default to SSE2 and-  -- SSE1 on x86, which results in defacto nondeterminism for how-  -- rounding behaves in the associated x87 floating point instructions-  -- because variations in the spill/fpu stack placement of arguments for-  -- operations would change the precision and final result of what-  -- would otherwise be the same expressions with respect to single or-  -- double precision IEEE floating point computations.-    ArchX86_64 -> True-    ArchX86    -> True-    _          -> False---isSse4_2Enabled :: DynFlags -> Bool-isSse4_2Enabled dflags = sseVersion dflags >= Just SSE42--isAvxEnabled :: DynFlags -> Bool-isAvxEnabled dflags = avx dflags || avx2 dflags || avx512f dflags--isAvx2Enabled :: DynFlags -> Bool-isAvx2Enabled dflags = avx2 dflags || avx512f dflags--isAvx512cdEnabled :: DynFlags -> Bool-isAvx512cdEnabled dflags = avx512cd dflags--isAvx512erEnabled :: DynFlags -> Bool-isAvx512erEnabled dflags = avx512er dflags--isAvx512fEnabled :: DynFlags -> Bool-isAvx512fEnabled dflags = avx512f dflags--isAvx512pfEnabled :: DynFlags -> Bool-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]-  | UnknownLD-  deriving Eq---- CompilerInfo tells us which C compiler we're using-data CompilerInfo-   = GCC-   | Clang-   | AppleClang-   | AppleClang51-   | UnknownCC-   deriving Eq---- -------------------------------------------------------------------------------- RTS hooks---- Convert sizes like "3.5M" into integers-decodeSize :: String -> Integer-decodeSize str-  | c == ""      = truncate n-  | c == "K" || c == "k" = truncate (n * 1000)-  | c == "M" || c == "m" = truncate (n * 1000 * 1000)-  | c == "G" || c == "g" = truncate (n * 1000 * 1000 * 1000)-  | otherwise            = throwGhcException (CmdLineError ("can't decode size: " ++ str))-  where (m, c) = span pred str-        n      = readRational m-        pred c = isDigit c || c == '.'--foreign import ccall unsafe "ghc_lib_parser_setHeapSize"       setHeapSize       :: Int -> IO ()-foreign import ccall unsafe "ghc_lib_parser_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

− compiler/main/DynFlags.hs-boot

@@ -1,19 +0,0 @@-module DynFlags where--import GhcPrelude-import GHC.Platform--data DynFlags-data DumpFlag-data GeneralFlag--targetPlatform           :: DynFlags -> Platform-pprUserLength            :: DynFlags -> Int-pprCols                  :: DynFlags -> Int-unsafeGlobalDynFlags     :: DynFlags-useUnicode               :: DynFlags -> Bool-useUnicodeSyntax         :: DynFlags -> Bool-shouldUseColor           :: DynFlags -> Bool-shouldUseHexWordLiterals :: DynFlags -> Bool-hasPprDebug              :: DynFlags -> Bool-hasNoDebugOutput         :: DynFlags -> Bool

compiler/main/ErrUtils.hs view

@@ -8,6 +8,7 @@ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE RecordWildCards #-} {-# LANGUAGE RankNTypes #-}+{-# LANGUAGE LambdaCase #-}  module ErrUtils (         -- * Basic types@@ -71,7 +72,7 @@ import Panic import qualified PprColour as Col import SrcLoc-import DynFlags+import GHC.Driver.Session import FastString (unpackFS) import StringBuffer (atLine, hGetStringBuffer, len, lexemeToString) import Json@@ -83,7 +84,7 @@ import qualified Data.Set as Set import Data.IORef import Data.Maybe       ( fromMaybe )-import Data.Ord+import Data.Function import Data.Time import Debug.Trace import Control.Monad@@ -209,12 +210,12 @@   -- are supposed to be in a standard format, and one without a location   -- would look strange.  Better to say explicitly "<no location info>". mkLocMessageAnn ann severity locn msg-    = sdocWithDynFlags $ \dflags ->-      let locn' = if gopt Opt_ErrorSpans dflags-                  then ppr locn-                  else ppr (srcSpanStart locn)+    = sdocOption sdocColScheme $ \col_scheme ->+      let locn' = sdocOption sdocErrorSpans $ \case+                     True  -> ppr locn+                     False -> ppr (srcSpanStart locn) -          sevColour = getSeverityColour severity (colScheme dflags)+          sevColour = getSeverityColour severity col_scheme            -- Add optional information           optAnn = case ann of@@ -226,8 +227,8 @@           header = locn' <> colon <+>                    coloured sevColour sevText <> optAnn -      in coloured (Col.sMessage (colScheme dflags))-                  (hang (coloured (Col.sHeader (colScheme dflags)) header) 4+      in coloured (Col.sMessage col_scheme)+                  (hang (coloured (Col.sHeader col_scheme) header) 4                         msg)    where@@ -246,7 +247,7 @@  getCaretDiagnostic :: Severity -> SrcSpan -> IO MsgDoc getCaretDiagnostic _ (UnhelpfulSpan _) = pure empty-getCaretDiagnostic severity (RealSrcSpan span) = do+getCaretDiagnostic severity (RealSrcSpan span _) = do   caretDiagnostic <$> getSrcLine (srcSpanFile span) row    where@@ -279,9 +280,9 @@      caretDiagnostic Nothing = empty     caretDiagnostic (Just srcLineWithNewline) =-      sdocWithDynFlags $ \ dflags ->-      let sevColour = getSeverityColour severity (colScheme dflags)-          marginColour = Col.sMargin (colScheme dflags)+      sdocOption sdocColScheme$ \col_scheme ->+      let sevColour = getSeverityColour severity col_scheme+          marginColour = Col.sMargin col_scheme       in       coloured marginColour (text marginSpace) <>       text ("\n") <>@@ -377,7 +378,8 @@ printBagOfErrors :: DynFlags -> Bag ErrMsg -> IO () printBagOfErrors dflags bag_of_errors   = sequence_ [ let style = mkErrStyle dflags unqual-                in putLogMsg dflags reason sev s style (formatErrDoc dflags doc)+                    ctx   = initSDocContext dflags style+                in putLogMsg dflags reason sev s style (formatErrDoc ctx doc)               | ErrMsg { errMsgSpan      = s,                          errMsgDoc       = doc,                          errMsgSeverity  = sev,@@ -385,13 +387,13 @@                          errMsgContext   = unqual } <- sortMsgBag (Just dflags)                                                                   bag_of_errors ] -formatErrDoc :: DynFlags -> ErrDoc -> SDoc-formatErrDoc dflags (ErrDoc important context supplementary)+formatErrDoc :: SDocContext -> ErrDoc -> SDoc+formatErrDoc ctx (ErrDoc important context supplementary)   = case msgs of         [msg] -> vcat msg         _ -> vcat $ map starred msgs     where-    msgs = filter (not . null) $ map (filter (not . Outputable.isEmpty dflags))+    msgs = filter (not . null) $ map (filter (not . Outputable.isEmpty ctx))         [important, context, supplementary]     starred = (bullet<+>) . vcat @@ -403,17 +405,14 @@                      , errMsgDoc       = doc                      , errMsgSeverity  = sev                      , errMsgContext   = unqual })-  = sdocWithDynFlags $ \dflags ->-    withPprStyle (mkErrStyle dflags unqual) $-    mkLocMessage sev s (formatErrDoc dflags doc)+  = sdocWithContext $ \ctx ->+    withErrStyle unqual $ mkLocMessage sev s (formatErrDoc ctx doc)  sortMsgBag :: Maybe DynFlags -> Bag ErrMsg -> [ErrMsg]-sortMsgBag dflags = maybeLimit . sortBy (maybeFlip cmp) . bagToList-  where maybeFlip :: (a -> a -> b) -> (a -> a -> b)-        maybeFlip-          | fromMaybe False (fmap reverseErrors dflags) = flip-          | otherwise                                   = id-        cmp = comparing errMsgSpan+sortMsgBag dflags = maybeLimit . sortBy (cmp `on` errMsgSpan) . bagToList+  where cmp+          | fromMaybe False (fmap reverseErrors dflags) = SrcLoc.rightmost_smallest+          | otherwise                                   = SrcLoc.leftmost_smallest         maybeLimit = case join (fmap maxErrors dflags) of           Nothing        -> id           Just err_limit -> take err_limit@@ -551,7 +550,7 @@                  --      by the --ddump-file-prefix flag.                | Just prefix <- dumpPrefixForce dflags                   = Just prefix-                 -- dump file location chosen by DriverPipeline.runPipeline+                 -- dump file location chosen by GHC.Driver.Pipeline.runPipeline                | Just prefix <- dumpPrefix dflags                   = Just prefix                  -- we haven't got a place to put a dump file.@@ -903,7 +902,7 @@ To actually produce the eventlog, you need an eventlog-capable GHC build:    With Hadrian:-  $ hadrian/build.sh -j "stage1.ghc-bin.ghc.link.opts += -eventlog"+  $ hadrian/build -j "stage1.ghc-bin.ghc.link.opts += -eventlog"    With Make:   $ make -j GhcStage2HcOpts+=-eventlog

compiler/main/ErrUtils.hs-boot view

@@ -6,7 +6,7 @@ import Outputable (SDoc, PprStyle ) import SrcLoc (SrcSpan) import Json-import {-# SOURCE #-} DynFlags ( DynFlags )+import {-# SOURCE #-} GHC.Driver.Session ( DynFlags )  type DumpAction = DynFlags -> PprStyle -> DumpOptions -> String                   -> DumpFormat -> SDoc -> IO ()

compiler/main/FileCleanup.hs view

@@ -9,12 +9,12 @@  import GhcPrelude -import DynFlags+import GHC.Driver.Session import ErrUtils import Outputable import Util import Exception-import DriverPhases+import GHC.Driver.Phases  import Control.Monad import Data.List

− compiler/main/GhcMonad.hs

@@ -1,204 +0,0 @@-{-# LANGUAGE CPP, DeriveFunctor, RankNTypes #-}-{-# OPTIONS_GHC -funbox-strict-fields #-}--- ----------------------------------------------------------------------------------- (c) The University of Glasgow, 2010------ The Session type and related functionality------ -------------------------------------------------------------------------------module GhcMonad (-        -- * 'Ghc' monad stuff-        GhcMonad(..),-        Ghc(..),-        GhcT(..), liftGhcT,-        reflectGhc, reifyGhc,-        getSessionDynFlags,-        liftIO,-        Session(..), withSession, modifySession, withTempSession,--        -- ** Warnings-        logWarnings, printException,-        WarnErrLogger, defaultWarnErrLogger-  ) where--import GhcPrelude--import MonadUtils-import HscTypes-import DynFlags-import Exception-import ErrUtils--import Control.Monad-import Data.IORef---- -------------------------------------------------------------------------------- | A monad that has all the features needed by GHC API calls.------ In short, a GHC monad------   - allows embedding of IO actions,------   - can log warnings,------   - allows handling of (extensible) exceptions, and------   - maintains a current session.------ If you do not use 'Ghc' or 'GhcT', make sure to call 'GHC.initGhcMonad'--- before any call to the GHC API functions can occur.----class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m where-  getSession :: m HscEnv-  setSession :: HscEnv -> m ()---- | Call the argument with the current session.-withSession :: GhcMonad m => (HscEnv -> m a) -> m a-withSession f = getSession >>= f---- | Grabs the DynFlags from the Session-getSessionDynFlags :: GhcMonad m => m DynFlags-getSessionDynFlags = withSession (return . hsc_dflags)---- | Set the current session to the result of applying the current session to--- the argument.-modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()-modifySession f = do h <- getSession-                     setSession $! f h--withSavedSession :: GhcMonad m => m a -> m a-withSavedSession m = do-  saved_session <- getSession-  m `gfinally` setSession saved_session---- | Call an action with a temporarily modified Session.-withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a-withTempSession f m =-  withSavedSession $ modifySession f >> m---- -------------------------------------------------------------------------------- | A monad that allows logging of warnings.--logWarnings :: GhcMonad m => WarningMessages -> m ()-logWarnings warns = do-  dflags <- getSessionDynFlags-  liftIO $ printOrThrowWarnings dflags warns---- -------------------------------------------------------------------------------- | A minimal implementation of a 'GhcMonad'.  If you need a custom monad,--- e.g., to maintain additional state consider wrapping this monad or using--- 'GhcT'.-newtype Ghc a = Ghc { unGhc :: Session -> IO a } deriving (Functor)---- | The Session is a handle to the complete state of a compilation--- session.  A compilation session consists of a set of modules--- constituting the current program or library, the context for--- interactive evaluation, and various caches.-data Session = Session !(IORef HscEnv)--instance Applicative Ghc where-  pure a = Ghc $ \_ -> return a-  g <*> m = do f <- g; a <- m; return (f a)--instance Monad Ghc where-  m >>= g  = Ghc $ \s -> do a <- unGhc m s; unGhc (g a) s--instance MonadIO Ghc where-  liftIO ioA = Ghc $ \_ -> ioA--instance MonadFix Ghc where-  mfix f = Ghc $ \s -> mfix (\x -> unGhc (f x) s)--instance ExceptionMonad Ghc where-  gcatch act handle =-      Ghc $ \s -> unGhc act s `gcatch` \e -> unGhc (handle e) s-  gmask f =-      Ghc $ \s -> gmask $ \io_restore ->-                             let-                                g_restore (Ghc m) = Ghc $ \s -> io_restore (m s)-                             in-                                unGhc (f g_restore) s--instance HasDynFlags Ghc where-  getDynFlags = getSessionDynFlags--instance GhcMonad Ghc where-  getSession = Ghc $ \(Session r) -> readIORef r-  setSession s' = Ghc $ \(Session r) -> writeIORef r s'---- | Reflect a computation in the 'Ghc' monad into the 'IO' monad.------ You can use this to call functions returning an action in the 'Ghc' monad--- inside an 'IO' action.  This is needed for some (too restrictive) callback--- arguments of some library functions:------ > libFunc :: String -> (Int -> IO a) -> IO a--- > ghcFunc :: Int -> Ghc a--- >--- > ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a--- > ghcFuncUsingLibFunc str =--- >   reifyGhc $ \s ->--- >     libFunc $ \i -> do--- >       reflectGhc (ghcFunc i) s----reflectGhc :: Ghc a -> Session -> IO a-reflectGhc m = unGhc m---- > Dual to 'reflectGhc'.  See its documentation.-reifyGhc :: (Session -> IO a) -> Ghc a-reifyGhc act = Ghc $ act---- -------------------------------------------------------------------------------- | A monad transformer to add GHC specific features to another monad.------ Note that the wrapped monad must support IO and handling of exceptions.-newtype GhcT m a = GhcT { unGhcT :: Session -> m a }-    deriving (Functor)--liftGhcT :: m a -> GhcT m a-liftGhcT m = GhcT $ \_ -> m--instance Applicative m => Applicative (GhcT m) where-  pure x  = GhcT $ \_ -> pure x-  g <*> m = GhcT $ \s -> unGhcT g s <*> unGhcT m s--instance Monad m => Monad (GhcT m) where-  m >>= k  = GhcT $ \s -> do a <- unGhcT m s; unGhcT (k a) s--instance MonadIO m => MonadIO (GhcT m) where-  liftIO ioA = GhcT $ \_ -> liftIO ioA--instance ExceptionMonad m => ExceptionMonad (GhcT m) where-  gcatch act handle =-      GhcT $ \s -> unGhcT act s `gcatch` \e -> unGhcT (handle e) s-  gmask f =-      GhcT $ \s -> gmask $ \io_restore ->-                           let-                              g_restore (GhcT m) = GhcT $ \s -> io_restore (m s)-                           in-                              unGhcT (f g_restore) s--instance MonadIO m => HasDynFlags (GhcT m) where-  getDynFlags = GhcT $ \(Session r) -> liftM hsc_dflags (liftIO $ readIORef r)--instance ExceptionMonad m => GhcMonad (GhcT m) where-  getSession = GhcT $ \(Session r) -> liftIO $ readIORef r-  setSession s' = GhcT $ \(Session r) -> liftIO $ writeIORef r s'----- | Print the error message and all warnings.  Useful inside exception---   handlers.  Clears warnings after printing.-printException :: GhcMonad m => SourceError -> m ()-printException err = do-  dflags <- getSessionDynFlags-  liftIO $ printBagOfErrors dflags (srcErrorMessages err)---- | A function called to log warnings and errors.-type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()--defaultWarnErrLogger :: WarnErrLogger-defaultWarnErrLogger Nothing  = return ()-defaultWarnErrLogger (Just e) = printException e-

compiler/main/HeaderInfo.hs view

@@ -23,7 +23,7 @@ import GhcPrelude  import GHC.Platform-import HscTypes+import GHC.Driver.Types import Parser           ( parseHeader ) import Lexer import FastString@@ -32,7 +32,7 @@ import PrelNames import StringBuffer import SrcLoc-import DynFlags+import GHC.Driver.Session import ErrUtils import Util import Outputable@@ -192,7 +192,7 @@                   _other -> do rest <- lazyLexBuf handle state' eof size                                return (t : rest)       _ | not eof   -> getMore handle state size-        | otherwise -> return [L (RealSrcSpan (last_loc state)) ITeof]+        | otherwise -> return [L (mkSrcSpanPs (last_loc state)) ITeof]                          -- parser assumes an ITeof sentinel at the end    getMore :: Handle -> PState -> Int -> IO [Located Token]@@ -216,7 +216,7 @@   lexAll state = case unP (lexer False return) state of                    POk _      t@(L _ ITeof) -> [t]                    POk state' t -> t : lexAll state'-                   _ -> [L (RealSrcSpan (last_loc state)) ITeof]+                   _ -> [L (mkSrcSpanPs (last_loc state)) ITeof]   -- | Parse OPTIONS and LANGUAGE pragmas of the source file.

− compiler/main/Hooks.hs

@@ -1,118 +0,0 @@--- \section[Hooks]{Low level API hooks}---- NB: this module is SOURCE-imported by DynFlags, and should primarily---     refer to *types*, rather than *code*--{-# LANGUAGE CPP #-}-module Hooks ( Hooks-             , emptyHooks-             , lookupHook-             , getHooked-               -- the hooks:-             , dsForeignsHook-             , tcForeignImportsHook-             , tcForeignExportsHook-             , hscFrontendHook-             , hscCompileCoreExprHook-             , ghcPrimIfaceHook-             , runPhaseHook-             , runMetaHook-             , linkHook-             , runRnSpliceHook-             , getValueSafelyHook-             , createIservProcessHook-             , stgToCmmHook-             , cmmToRawCmmHook-             ) where--import GhcPrelude--import DynFlags-import PipelineMonad-import HscTypes-import GHC.Hs.Decls-import GHC.Hs.Binds-import GHC.Hs.Expr-import OrdList-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 Module-import TyCon-import CostCentre-import GHC.Stg.Syntax-import Stream-import GHC.Cmm-import GHC.Hs.Extension--import Data.Maybe--{--************************************************************************-*                                                                      *-\subsection{Hooks}-*                                                                      *-************************************************************************--}---- | Hooks can be used by GHC API clients to replace parts of---   the compiler pipeline. If a hook is not installed, GHC---   uses the default built-in behaviour--emptyHooks :: Hooks-emptyHooks = Hooks-  { dsForeignsHook         = Nothing-  , tcForeignImportsHook   = Nothing-  , tcForeignExportsHook   = Nothing-  , hscFrontendHook        = Nothing-  , hscCompileCoreExprHook = Nothing-  , ghcPrimIfaceHook       = Nothing-  , runPhaseHook           = Nothing-  , runMetaHook            = Nothing-  , linkHook               = Nothing-  , runRnSpliceHook        = Nothing-  , getValueSafelyHook     = Nothing-  , createIservProcessHook = Nothing-  , stgToCmmHook           = Nothing-  , cmmToRawCmmHook        = Nothing-  }--data Hooks = Hooks-  { 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)-  , ghcPrimIfaceHook       :: Maybe ModIface-  , runPhaseHook           :: Maybe (PhasePlus -> FilePath -> DynFlags-                                         -> CompPipeline (PhasePlus, FilePath))-  , runMetaHook            :: Maybe (MetaHook TcM)-  , 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)-  , stgToCmmHook           :: Maybe (DynFlags -> Module -> [TyCon] -> CollectedCCs-                                 -> [CgStgTopBinding] -> HpcInfo -> Stream IO CmmGroup ())-  , cmmToRawCmmHook        :: Maybe (DynFlags -> Maybe Module -> Stream IO CmmGroup ()-                                 -> IO (Stream IO RawCmmGroup ()))-  }--getHooked :: (Functor f, HasDynFlags f) => (Hooks -> Maybe a) -> a -> f a-getHooked hook def = fmap (lookupHook hook def) getDynFlags--lookupHook :: (Hooks -> Maybe a) -> a -> DynFlags -> a-lookupHook hook def = fromMaybe def . hook . hooks

− compiler/main/Hooks.hs-boot

@@ -1,7 +0,0 @@-module Hooks where--import GhcPrelude ()--data Hooks--emptyHooks :: Hooks

− compiler/main/HscTypes.hs

@@ -1,3268 +0,0 @@-{--(c) The University of Glasgow, 2006--\section[HscTypes]{Types for the per-module compiler}--}--{-# LANGUAGE CPP, ScopedTypeVariables #-}-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE RecordWildCards #-}-{-# LANGUAGE ViewPatterns #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE TypeSynonymInstances #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE UndecidableInstances #-}-{-# LANGUAGE DataKinds #-}---- | Types for the per-module compiler-module HscTypes (-        -- * compilation state-        HscEnv(..), hscEPS,-        FinderCache, FindResult(..), InstalledFindResult(..),-        Target(..), TargetId(..), InputFileBuffer, pprTarget, pprTargetId,-        HscStatus(..),-        IServ(..),--        -- * ModuleGraph-        ModuleGraph, emptyMG, mkModuleGraph, extendMG, mapMG,-        mgModSummaries, mgElemModule, mgLookupModule,-        needsTemplateHaskellOrQQ, mgBootModules,--        -- * Hsc monad-        Hsc(..), runHsc, mkInteractiveHscEnv, runInteractiveHsc,--        -- * Information about modules-        ModDetails(..), emptyModDetails,-        ModGuts(..), CgGuts(..), ForeignStubs(..), appendStubC,-        ImportedMods, ImportedBy(..), importedByUser, ImportedModsVal(..), SptEntry(..),-        ForeignSrcLang(..),-        phaseForeignLanguage,--        ModSummary(..), ms_imps, ms_installed_mod, ms_mod_name, ms_home_imps,-        home_imps, ms_home_allimps, ms_home_srcimps, showModMsg, isBootSummary,-        msHsFilePath, msHiFilePath, msObjFilePath,-        SourceModified(..), isTemplateHaskellOrQQNonBoot,--        -- * Information about the module being compiled-        -- (re-exported from DriverPhases)-        HscSource(..), isHsBootOrSig, isHsigFile, hscSourceString,---        -- * State relating to modules in this package-        HomePackageTable, HomeModInfo(..), emptyHomePackageTable,-        lookupHpt, eltsHpt, filterHpt, allHpt, mapHpt, delFromHpt,-        addToHpt, addListToHpt, lookupHptDirectly, listToHpt,-        hptCompleteSigs,-        hptInstances, hptRules, pprHPT,--        -- * State relating to known packages-        ExternalPackageState(..), EpsStats(..), addEpsInStats,-        PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,-        lookupIfaceByModule, emptyPartialModIface, emptyFullModIface, lookupHptByModule,--        PackageInstEnv, PackageFamInstEnv, PackageRuleBase,-        PackageCompleteMatchMap,--        mkSOName, mkHsSOName, soExt,--        -- * Metaprogramming-        MetaRequest(..),-        MetaResult, -- data constructors not exported to ensure correct response type-        metaRequestE, metaRequestP, metaRequestT, metaRequestD, metaRequestAW,-        MetaHook,--        -- * Annotations-        prepareAnnotations,--        -- * Interactive context-        InteractiveContext(..), emptyInteractiveContext,-        icPrintUnqual, icInScopeTTs, icExtendGblRdrEnv,-        extendInteractiveContext, extendInteractiveContextWithIds,-        substInteractiveContext,-        setInteractivePrintName, icInteractiveModule,-        InteractiveImport(..), setInteractivePackage,-        mkPrintUnqualified, pprModulePrefix,-        mkQualPackage, mkQualModule, pkgQual,--        -- * Interfaces-        ModIface, PartialModIface, ModIface_(..), ModIfaceBackend(..),-        mkIfaceWarnCache, mkIfaceHashCache, mkIfaceFixCache,-        emptyIfaceWarnCache, mi_boot, mi_fix,-        mi_semantic_module,-        mi_free_holes,-        renameFreeHoles,--        -- * Fixity-        FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,--        -- * TyThings and type environments-        TyThing(..),  tyThingAvailInfo,-        tyThingTyCon, tyThingDataCon, tyThingConLike,-        tyThingId, tyThingCoAxiom, tyThingParent_maybe, tyThingsTyCoVars,-        implicitTyThings, implicitTyConThings, implicitClassThings,-        isImplicitTyThing,--        TypeEnv, lookupType, lookupTypeHscEnv, mkTypeEnv, emptyTypeEnv,-        typeEnvFromEntities, mkTypeEnvWithImplicits,-        extendTypeEnv, extendTypeEnvList,-        extendTypeEnvWithIds, plusTypeEnv,-        lookupTypeEnv,-        typeEnvElts, typeEnvTyCons, typeEnvIds, typeEnvPatSyns,-        typeEnvDataCons, typeEnvCoAxioms, typeEnvClasses,--        -- * MonadThings-        MonadThings(..),--        -- * Information on imports and exports-        WhetherHasOrphans, IsBootInterface, Usage(..),-        Dependencies(..), noDependencies,-        updNameCache,-        IfaceExport,--        -- * Warnings-        Warnings(..), WarningTxt(..), plusWarns,--        -- * Linker stuff-        Linkable(..), isObjectLinkable, linkableObjs,-        Unlinked(..), CompiledByteCode,-        isObject, nameOfObject, isInterpretable, byteCodeOfObject,--        -- * Program coverage-        HpcInfo(..), emptyHpcInfo, isHpcUsed, AnyHpcUsage,--        -- * Breakpoints-        ModBreaks (..), emptyModBreaks,--        -- * Safe Haskell information-        IfaceTrustInfo, getSafeMode, setSafeMode, noIfaceTrustInfo,-        trustInfoToNum, numToTrustInfo, IsSafeImport,--        -- * result of the parser-        HsParsedModule(..),--        -- * Compilation errors and warnings-        SourceError, GhcApiError, mkSrcErr, srcErrorMessages, mkApiErr,-        throwOneError, throwErrors, handleSourceError,-        handleFlagWarnings, printOrThrowWarnings,--        -- * COMPLETE signature-        CompleteMatch(..), CompleteMatchMap,-        mkCompleteMatchMap, extendCompleteMatchMap-    ) where--#include "HsVersions.h"--import GhcPrelude--import ByteCodeTypes-import InteractiveEvalTypes ( Resume )-import GHCi.Message         ( Pipe )-import GHCi.RemoteTypes-import GHC.ForeignSrcLang--import UniqFM-import GHC.Hs-import RdrName-import Avail-import Module-import InstEnv          ( InstEnv, ClsInst, identicalClsInstHead )-import FamInstEnv-import CoreSyn          ( CoreProgram, RuleBase, CoreRule )-import Name-import NameEnv-import VarSet-import Var-import Id-import IdInfo           ( IdDetails(..), RecSelParent(..))-import Type--import ApiAnnotation    ( ApiAnns )-import Annotations      ( Annotation, AnnEnv, mkAnnEnv, plusAnnEnv )-import Class-import TyCon-import CoAxiom-import ConLike-import DataCon-import PatSyn-import PrelNames        ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule )-import TysWiredIn-import Packages hiding  ( Version(..) )-import CmdLineParser-import DynFlags-import LinkerTypes      ( DynLinker, Linkable(..), Unlinked(..), SptEntry(..) )-import DriverPhases     ( Phase, HscSource(..), hscSourceString-                        , isHsBootOrSig, isHsigFile )-import qualified DriverPhases as Phase-import BasicTypes-import GHC.Iface.Syntax-import Maybes-import Outputable-import SrcLoc-import Unique-import UniqDFM-import FastString-import StringBuffer     ( StringBuffer )-import Fingerprint-import MonadUtils-import Bag-import Binary-import ErrUtils-import NameCache-import GHC.Platform-import Util-import UniqDSet-import GHC.Serialized   ( Serialized )-import qualified GHC.LanguageExtensions as LangExt--import Foreign-import Control.Monad    ( guard, liftM, ap )-import Data.IORef-import Data.Time-import Exception-import System.FilePath-import Control.Concurrent-import System.Process   ( ProcessHandle )-import Control.DeepSeq-import Control.Monad.Trans.Reader-import Control.Monad.Trans.Class---- -------------------------------------------------------------------------------- Compilation state--- --------------------------------------------------------------------------------- | Status of a compilation to hard-code-data HscStatus-    -- | Nothing to do.-    = HscNotGeneratingCode ModIface ModDetails-    -- | Nothing to do because code already exists.-    | HscUpToDate ModIface ModDetails-    -- | Update boot file result.-    | HscUpdateBoot ModIface ModDetails-    -- | Generate signature file (backpack)-    | HscUpdateSig ModIface ModDetails-    -- | Recompile this module.-    | HscRecomp-        { hscs_guts       :: CgGuts-          -- ^ Information for the code generator.-        , hscs_mod_location :: !ModLocation-          -- ^ Module info-        , hscs_mod_details :: !ModDetails-        , hscs_partial_iface  :: !PartialModIface-          -- ^ Partial interface-        , hscs_old_iface_hash :: !(Maybe Fingerprint)-          -- ^ Old interface hash for this compilation, if an old interface file-          -- exists. Pass to `hscMaybeWriteIface` when writing the interface to-          -- avoid updating the existing interface when the interface isn't-          -- changed.-        , hscs_iface_dflags :: !DynFlags-          -- ^ Generate final iface using this DynFlags.-          -- FIXME (osa): I don't understand why this is necessary, but I spent-          -- almost two days trying to figure this out and I couldn't .. perhaps-          -- someone who understands this code better will remove this later.-        }--- Should HscStatus contain the HomeModInfo?--- All places where we return a status we also return a HomeModInfo.---- -------------------------------------------------------------------------------- The Hsc monad: Passing an environment and warning state--newtype Hsc a = Hsc (HscEnv -> WarningMessages -> IO (a, WarningMessages))-    deriving (Functor)--instance Applicative Hsc where-    pure a = Hsc $ \_ w -> return (a, w)-    (<*>) = ap--instance Monad Hsc where-    Hsc m >>= k = Hsc $ \e w -> do (a, w1) <- m e w-                                   case k a of-                                       Hsc k' -> k' e w1--instance MonadIO Hsc where-    liftIO io = Hsc $ \_ w -> do a <- io; return (a, w)--instance HasDynFlags Hsc where-    getDynFlags = Hsc $ \e w -> return (hsc_dflags e, w)--runHsc :: HscEnv -> Hsc a -> IO a-runHsc hsc_env (Hsc hsc) = do-    (a, w) <- hsc hsc_env emptyBag-    printOrThrowWarnings (hsc_dflags hsc_env) w-    return a--mkInteractiveHscEnv :: HscEnv -> HscEnv-mkInteractiveHscEnv hsc_env = hsc_env{ hsc_dflags = interactive_dflags }-  where-    interactive_dflags = ic_dflags (hsc_IC hsc_env)--runInteractiveHsc :: HscEnv -> Hsc a -> IO a--- A variant of runHsc that switches in the DynFlags from the--- InteractiveContext before running the Hsc computation.-runInteractiveHsc hsc_env = runHsc (mkInteractiveHscEnv hsc_env)---- -------------------------------------------------------------------------------- Source Errors---- When the compiler (HscMain) discovers errors, it throws an--- exception in the IO monad.--mkSrcErr :: ErrorMessages -> SourceError-mkSrcErr = SourceError--srcErrorMessages :: SourceError -> ErrorMessages-srcErrorMessages (SourceError msgs) = msgs--mkApiErr :: DynFlags -> SDoc -> GhcApiError-mkApiErr dflags msg = GhcApiError (showSDoc dflags msg)--throwErrors :: MonadIO io => ErrorMessages -> io a-throwErrors = liftIO . throwIO . mkSrcErr--throwOneError :: MonadIO io => ErrMsg -> io a-throwOneError = throwErrors . unitBag---- | A source error is an error that is caused by one or more errors in the--- source code.  A 'SourceError' is thrown by many functions in the--- compilation pipeline.  Inside GHC these errors are merely printed via--- 'log_action', but API clients may treat them differently, for example,--- insert them into a list box.  If you want the default behaviour, use the--- idiom:------ > handleSourceError printExceptionAndWarnings $ do--- >   ... api calls that may fail ...------ The 'SourceError's error messages can be accessed via 'srcErrorMessages'.--- This list may be empty if the compiler failed due to @-Werror@--- ('Opt_WarnIsError').------ See 'printExceptionAndWarnings' for more information on what to take care--- of when writing a custom error handler.-newtype SourceError = SourceError ErrorMessages--instance Show SourceError where-  show (SourceError msgs) = unlines . map show . bagToList $ msgs--instance Exception SourceError---- | Perform the given action and call the exception handler if the action--- throws a 'SourceError'.  See 'SourceError' for more information.-handleSourceError :: (ExceptionMonad m) =>-                     (SourceError -> m a) -- ^ exception handler-                  -> m a -- ^ action to perform-                  -> m a-handleSourceError handler act =-  gcatch act (\(e :: SourceError) -> handler e)---- | An error thrown if the GHC API is used in an incorrect fashion.-newtype GhcApiError = GhcApiError String--instance Show GhcApiError where-  show (GhcApiError msg) = msg--instance Exception GhcApiError---- | 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 = 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 -> [Warn] -> IO ()-handleFlagWarnings dflags warns = do-  let warns' = filter (shouldPrintWarning dflags . warnReason)  warns--      -- 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--{--************************************************************************-*                                                                      *-\subsection{HscEnv}-*                                                                      *-************************************************************************--}---- | HscEnv is like 'Session', except that some of the fields are immutable.--- An HscEnv is used to compile a single module from plain Haskell source--- code (after preprocessing) to either C, assembly or C--. It's also used--- to store the dynamic linker state to allow for multiple linkers in the--- same address space.--- Things like the module graph don't change during a single compilation.------ Historical note: \"hsc\" used to be the name of the compiler binary,--- when there was a separate driver and compiler.  To compile a single--- module, the driver would invoke hsc on the source code... so nowadays--- we think of hsc as the layer of the compiler that deals with compiling--- a single module.-data HscEnv-  = HscEnv {-        hsc_dflags :: DynFlags,-                -- ^ The dynamic flag settings--        hsc_targets :: [Target],-                -- ^ The targets (or roots) of the current session--        hsc_mod_graph :: ModuleGraph,-                -- ^ The module graph of the current session--        hsc_IC :: InteractiveContext,-                -- ^ The context for evaluating interactive statements--        hsc_HPT    :: HomePackageTable,-                -- ^ The home package table describes already-compiled-                -- home-package modules, /excluding/ the module we-                -- are compiling right now.-                -- (In one-shot mode the current module is the only-                -- home-package module, so hsc_HPT is empty.  All other-                -- modules count as \"external-package\" modules.-                -- However, even in GHCi mode, hi-boot interfaces are-                -- demand-loaded into the external-package table.)-                ---                -- 'hsc_HPT' is not mutable because we only demand-load-                -- external packages; the home package is eagerly-                -- loaded, module by module, by the compilation manager.-                ---                -- The HPT may contain modules compiled earlier by @--make@-                -- but not actually below the current module in the dependency-                -- graph.-                ---                -- (This changes a previous invariant: changed Jan 05.)--        hsc_EPS :: {-# UNPACK #-} !(IORef ExternalPackageState),-                -- ^ Information about the currently loaded external packages.-                -- This is mutable because packages will be demand-loaded during-                -- a compilation run as required.--        hsc_NC  :: {-# UNPACK #-} !(IORef NameCache),-                -- ^ As with 'hsc_EPS', this is side-effected by compiling to-                -- reflect sucking in interface files.  They cache the state of-                -- external interface files, in effect.--        hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),-                -- ^ The cached result of performing finding in the file system--        hsc_type_env_var :: Maybe (Module, IORef TypeEnv)-                -- ^ Used for one-shot compilation only, to initialise-                -- the 'IfGblEnv'. See 'TcRnTypes.tcg_type_env_var' for-                -- 'TcRnTypes.TcGblEnv'.  See also Note [hsc_type_env_var hack]--        , hsc_iserv :: MVar (Maybe IServ)-                -- ^ interactive server process.  Created the first-                -- time it is needed.--        , hsc_dynLinker :: DynLinker-                -- ^ dynamic linker.-- }---- Note [hsc_type_env_var hack]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- hsc_type_env_var is used to initialize tcg_type_env_var, and--- eventually it is the mutable variable that is queried from--- if_rec_types to get a TypeEnv.  So, clearly, it's something--- related to knot-tying (see Note [Tying the knot]).--- hsc_type_env_var is used in two places: initTcRn (where--- it initializes tcg_type_env_var) and initIfaceCheck--- (where it initializes if_rec_types).------ But why do we need a way to feed a mutable variable in?  Why--- can't we just initialize tcg_type_env_var when we start--- typechecking?  The problem is we need to knot-tie the--- EPS, and we may start adding things to the EPS before type--- checking starts.------ Here is a concrete example. Suppose we are running--- "ghc -c A.hs", and we have this file system state:------  A.hs-boot   A.hi-boot **up to date**---  B.hs        B.hi      **up to date**---  A.hs        A.hi      **stale**------ The first thing we do is run checkOldIface on A.hi.--- checkOldIface will call loadInterface on B.hi so it can--- get its hands on the fingerprints, to find out if A.hi--- needs recompilation.  But loadInterface also populates--- the EPS!  And so if compilation turns out to be necessary,--- as it is in this case, the thunks we put into the EPS for--- B.hi need to have the correct if_rec_types mutable variable--- to query.------ If the mutable variable is only allocated WHEN we start--- typechecking, then that's too late: we can't get the--- information to the thunks.  So we need to pre-commit--- to a type variable in 'hscIncrementalCompile' BEFORE we--- check the old interface.------ This is all a massive hack because arguably checkOldIface--- should not populate the EPS. But that's a refactor for--- another day.---data IServ = IServ-  { iservPipe :: Pipe-  , iservProcess :: ProcessHandle-  , iservLookupSymbolCache :: IORef (UniqFM (Ptr ()))-  , iservPendingFrees :: [HValueRef]-  }---- | Retrieve the ExternalPackageState cache.-hscEPS :: HscEnv -> IO ExternalPackageState-hscEPS hsc_env = readIORef (hsc_EPS hsc_env)---- | A compilation target.------ A target may be supplied with the actual text of the--- module.  If so, use this instead of the file contents (this--- is for use in an IDE where the file hasn't been saved by--- the user yet).-data Target-  = Target {-      targetId           :: TargetId, -- ^ module or filename-      targetAllowObjCode :: Bool,     -- ^ object code allowed?-      targetContents     :: Maybe (InputFileBuffer, UTCTime)-      -- ^ Optional in-memory buffer containing the source code GHC should-      -- use for this target instead of reading it from disk.-      ---      -- Since GHC version 8.10 modules which require preprocessors such as-      -- Literate Haskell or CPP to run are also supported.-      ---      -- If a corresponding source file does not exist on disk this will-      -- result in a 'SourceError' exception if @targetId = TargetModule _@-      -- is used. However together with @targetId = TargetFile _@ GHC will-      -- not complain about the file missing.-    }--data TargetId-  = TargetModule ModuleName-        -- ^ A module name: search for the file-  | TargetFile FilePath (Maybe Phase)-        -- ^ A filename: preprocess & parse it to find the module name.-        -- If specified, the Phase indicates how to compile this file-        -- (which phase to start from).  Nothing indicates the starting phase-        -- should be determined from the suffix of the filename.-  deriving Eq--type InputFileBuffer = StringBuffer--pprTarget :: Target -> SDoc-pprTarget (Target id obj _) =-    (if obj then char '*' else empty) <> pprTargetId id--instance Outputable Target where-    ppr = pprTarget--pprTargetId :: TargetId -> SDoc-pprTargetId (TargetModule m) = ppr m-pprTargetId (TargetFile f _) = text f--instance Outputable TargetId where-    ppr = pprTargetId--{--************************************************************************-*                                                                      *-\subsection{Package and Module Tables}-*                                                                      *-************************************************************************--}---- | Helps us find information about modules in the home package-type HomePackageTable  = DModuleNameEnv HomeModInfo-        -- Domain = modules in the home package that have been fully compiled-        -- "home" unit id cached here for convenience---- | Helps us find information about modules in the imported packages-type PackageIfaceTable = ModuleEnv ModIface-        -- Domain = modules in the imported packages---- | Constructs an empty HomePackageTable-emptyHomePackageTable :: HomePackageTable-emptyHomePackageTable  = emptyUDFM---- | Constructs an empty PackageIfaceTable-emptyPackageIfaceTable :: PackageIfaceTable-emptyPackageIfaceTable = emptyModuleEnv--pprHPT :: HomePackageTable -> SDoc--- A bit arbitrary for now-pprHPT hpt = pprUDFM hpt $ \hms ->-    vcat [ hang (ppr (mi_module (hm_iface hm)))-              2 (ppr (md_types (hm_details hm)))-         | hm <- hms ]--lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo-lookupHpt = lookupUDFM--lookupHptDirectly :: HomePackageTable -> Unique -> Maybe HomeModInfo-lookupHptDirectly = lookupUDFM_Directly--eltsHpt :: HomePackageTable -> [HomeModInfo]-eltsHpt = eltsUDFM--filterHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> HomePackageTable-filterHpt = filterUDFM--allHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> Bool-allHpt = allUDFM--mapHpt :: (HomeModInfo -> HomeModInfo) -> HomePackageTable -> HomePackageTable-mapHpt = mapUDFM--delFromHpt :: HomePackageTable -> ModuleName -> HomePackageTable-delFromHpt = delFromUDFM--addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable-addToHpt = addToUDFM--addListToHpt-  :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable-addListToHpt = addListToUDFM--listToHpt :: [(ModuleName, HomeModInfo)] -> HomePackageTable-listToHpt = listToUDFM--lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo--- The HPT is indexed by ModuleName, not Module,--- we must check for a hit on the right Module-lookupHptByModule hpt mod-  = case lookupHpt hpt (moduleName mod) of-      Just hm | mi_module (hm_iface hm) == mod -> Just hm-      _otherwise                               -> Nothing---- | Information about modules in the package being compiled-data HomeModInfo-  = HomeModInfo {-      hm_iface    :: !ModIface,-        -- ^ The basic loaded interface file: every loaded module has one of-        -- these, even if it is imported from another package-      hm_details  :: !ModDetails,-        -- ^ Extra information that has been created from the 'ModIface' for-        -- the module, typically during typechecking-      hm_linkable :: !(Maybe Linkable)-        -- ^ The actual artifact we would like to link to access things in-        -- this module.-        ---        -- 'hm_linkable' might be Nothing:-        ---        --   1. If this is an .hs-boot module-        ---        --   2. Temporarily during compilation if we pruned away-        --      the old linkable because it was out of date.-        ---        -- After a complete compilation ('GHC.load'), all 'hm_linkable' fields-        -- in the 'HomePackageTable' will be @Just@.-        ---        -- When re-linking a module ('HscMain.HscNoRecomp'), we construct the-        -- 'HomeModInfo' by building a new 'ModDetails' from the old-        -- 'ModIface' (only).-    }---- | Find the 'ModIface' for a 'Module', searching in both the loaded home--- and external package module information-lookupIfaceByModule-        :: HomePackageTable-        -> PackageIfaceTable-        -> Module-        -> Maybe ModIface-lookupIfaceByModule hpt pit mod-  = case lookupHptByModule hpt mod of-       Just hm -> Just (hm_iface hm)-       Nothing -> lookupModuleEnv pit mod---- If the module does come from the home package, why do we look in the PIT as well?--- (a) In OneShot mode, even home-package modules accumulate in the PIT--- (b) Even in Batch (--make) mode, there is *one* case where a home-package---     module is in the PIT, namely GHC.Prim when compiling the base package.--- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package--- of its own, but it doesn't seem worth the bother.--hptCompleteSigs :: HscEnv -> [CompleteMatch]-hptCompleteSigs = hptAllThings  (md_complete_sigs . hm_details)---- | Find all the instance declarations (of classes and families) from--- the Home Package Table filtered by the provided predicate function.--- Used in @tcRnImports@, to select the instances that are in the--- transitive closure of imports from the currently compiled module.-hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])-hptInstances hsc_env want_this_module-  = let (insts, famInsts) = unzip $ flip hptAllThings hsc_env $ \mod_info -> do-                guard (want_this_module (moduleName (mi_module (hm_iface mod_info))))-                let details = hm_details mod_info-                return (md_insts details, md_fam_insts details)-    in (concat insts, concat famInsts)---- | Get rules from modules "below" this one (in the dependency sense)-hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]-hptRules = hptSomeThingsBelowUs (md_rules . hm_details) False----- | Get annotations from modules "below" this one (in the dependency sense)-hptAnns :: HscEnv -> Maybe [(ModuleName, IsBootInterface)] -> [Annotation]-hptAnns hsc_env (Just deps) = hptSomeThingsBelowUs (md_anns . hm_details) False hsc_env deps-hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env--hptAllThings :: (HomeModInfo -> [a]) -> HscEnv -> [a]-hptAllThings extract hsc_env = concatMap extract (eltsHpt (hsc_HPT hsc_env))---- | Get things from modules "below" this one (in the dependency sense)--- C.f Inst.hptInstances-hptSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> [(ModuleName, IsBootInterface)] -> [a]-hptSomeThingsBelowUs extract include_hi_boot hsc_env deps-  | isOneShot (ghcMode (hsc_dflags hsc_env)) = []--  | otherwise-  = let hpt = hsc_HPT hsc_env-    in-    [ thing-    |   -- Find each non-hi-boot module below me-      (mod, is_boot_mod) <- deps-    , include_hi_boot || not is_boot_mod--        -- unsavoury: when compiling the base package with --make, we-        -- sometimes try to look up RULES etc for GHC.Prim. GHC.Prim won't-        -- be in the HPT, because we never compile it; it's in the EPT-        -- instead. ToDo: clean up, and remove this slightly bogus filter:-    , mod /= moduleName gHC_PRIM--        -- Look it up in the HPT-    , let things = case lookupHpt hpt mod of-                    Just info -> extract info-                    Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg []-          msg = vcat [text "missing module" <+> ppr mod,-                      text "Probable cause: out-of-date interface files"]-                        -- This really shouldn't happen, but see #962--        -- And get its dfuns-    , thing <- things ]---{--************************************************************************-*                                                                      *-\subsection{Metaprogramming}-*                                                                      *-************************************************************************--}---- | The supported metaprogramming result types-data MetaRequest-  = 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 GhcPs   }-  | MetaResP  { unMetaResP  :: LPat GhcPs      }-  | MetaResT  { unMetaResT  :: LHsType GhcPs   }-  | MetaResD  { unMetaResD  :: [LHsDecl GhcPs] }-  | MetaResAW { unMetaResAW :: Serialized        }--type MetaHook f = MetaRequest -> LHsExpr GhcTc -> f MetaResult--metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)-metaRequestE h = fmap unMetaResE . h (MetaE MetaResE)--metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)-metaRequestP h = fmap unMetaResP . h (MetaP MetaResP)--metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)-metaRequestT h = fmap unMetaResT . h (MetaT MetaResT)--metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]-metaRequestD h = fmap unMetaResD . h (MetaD MetaResD)--metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized-metaRequestAW h = fmap unMetaResAW . h (MetaAW MetaResAW)--{--************************************************************************-*                                                                      *-\subsection{Dealing with Annotations}-*                                                                      *-************************************************************************--}---- | Deal with gathering annotations in from all possible places---   and combining them into a single 'AnnEnv'-prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv-prepareAnnotations hsc_env mb_guts = do-    eps <- hscEPS hsc_env-    let -- Extract annotations from the module being compiled if supplied one-        mb_this_module_anns = fmap (mkAnnEnv . mg_anns) mb_guts-        -- Extract dependencies of the module if we are supplied one,-        -- otherwise load annotations from all home package table-        -- entries regardless of dependency ordering.-        home_pkg_anns  = (mkAnnEnv . hptAnns hsc_env) $ fmap (dep_mods . mg_deps) mb_guts-        other_pkg_anns = eps_ann_env eps-        ann_env        = foldl1' plusAnnEnv $ catMaybes [mb_this_module_anns,-                                                         Just home_pkg_anns,-                                                         Just other_pkg_anns]-    return ann_env--{--************************************************************************-*                                                                      *-\subsection{The Finder cache}-*                                                                      *-************************************************************************--}---- | The 'FinderCache' maps modules to the result of--- searching for that module. It records the results of searching for--- modules along the search path. On @:load@, we flush the entire--- contents of this cache.----type FinderCache = InstalledModuleEnv InstalledFindResult--data InstalledFindResult-  = InstalledFound ModLocation InstalledModule-  | InstalledNoPackage InstalledUnitId-  | InstalledNotFound [FilePath] (Maybe InstalledUnitId)---- | The result of searching for an imported module.------ NB: FindResult manages both user source-import lookups--- (which can result in 'Module') as well as direct imports--- for interfaces (which always result in 'InstalledModule').-data FindResult-  = Found ModLocation Module-        -- ^ The module was found-  | NoPackage UnitId-        -- ^ The requested package was not found-  | FoundMultiple [(Module, ModuleOrigin)]-        -- ^ _Error_: both in multiple packages--        -- | Not found-  | NotFound-      { fr_paths       :: [FilePath]       -- Places where I looked--      , fr_pkg         :: Maybe UnitId  -- Just p => module is in this package's-                                           --           manifest, but couldn't find-                                           --           the .hi file--      , fr_mods_hidden :: [UnitId]      -- Module is in these packages,-                                           --   but the *module* is hidden--      , fr_pkgs_hidden :: [UnitId]      -- Module is in these packages,-                                           --   but the *package* is hidden--        -- Modules are in these packages, but it is unusable-      , fr_unusables   :: [(UnitId, UnusablePackageReason)]--      , fr_suggestions :: [ModuleSuggestion] -- Possible mis-spelled modules-      }--{--************************************************************************-*                                                                      *-\subsection{Symbol tables and Module details}-*                                                                      *-************************************************************************--}--{- Note [Interface file stages]-   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~--Interface files have two possible stages.--* A partial stage built from the result of the core pipeline.-* A fully instantiated form. Which also includes fingerprints and-  potentially information provided by backends.--We can build a full interface file two ways:-* Directly from a partial one:-  Then we omit backend information and mostly compute fingerprints.-* From a partial one + information produced by a backend.-  Then we store the provided information and fingerprint both.--}--type PartialModIface = ModIface_ 'ModIfaceCore-type ModIface = ModIface_ 'ModIfaceFinal---- | Extends a PartialModIface with information which is either:--- * Computed after codegen--- * Or computed just before writing the iface to disk. (Hashes)--- In order to fully instantiate it.-data ModIfaceBackend = ModIfaceBackend-  { 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 the module, excluding-    -- optimisation flags-  , mi_opt_hash :: !Fingerprint-    -- ^ Hash of optimisation flags-  , mi_hpc_hash :: !Fingerprint-    -- ^ Hash of hpc flags-  , mi_plugin_hash :: !Fingerprint-    -- ^ Hash of plugins-  , mi_orphan :: !WhetherHasOrphans-    -- ^ Whether this module has orphans-  , mi_finsts :: !WhetherHasFamInst-    -- ^ Whether this module has family instances. See Note [The type family-    -- instance consistency story].-  , mi_exp_hash :: !Fingerprint-    -- ^ Hash of export list-  , mi_orphan_hash :: !Fingerprint-    -- ^ Hash for orphan rules, class and family instances combined--    -- Cached environments for easy lookup. These are computed (lazily) from-    -- other fields and are not put into the interface file.-    -- Not really produced by the backend but there is no need to create them-    -- any earlier.-  , mi_warn_fn :: !(OccName -> Maybe WarningTxt)-    -- ^ Cached lookup for 'mi_warns'-  , mi_fix_fn :: !(OccName -> Maybe Fixity)-    -- ^ Cached lookup for 'mi_fixities'-  , mi_hash_fn :: !(OccName -> Maybe (OccName, Fingerprint))-    -- ^ Cached lookup for 'mi_decls'. The @Nothing@ in 'mi_hash_fn' means that-    -- the thing isn't in decls. It's useful to know that when seeing if we are-    -- up to date wrt. the old interface. The 'OccName' is the parent of the-    -- name, if it has one.-  }--data ModIfacePhase-  = ModIfaceCore-  -- ^ Partial interface built based on output of core pipeline.-  | ModIfaceFinal---- | Selects a IfaceDecl representation.--- For fully instantiated interfaces we also maintain--- a fingerprint, which is used for recompilation checks.-type family IfaceDeclExts (phase :: ModIfacePhase) where-  IfaceDeclExts 'ModIfaceCore = IfaceDecl-  IfaceDeclExts 'ModIfaceFinal = (Fingerprint, IfaceDecl)--type family IfaceBackendExts (phase :: ModIfacePhase) where-  IfaceBackendExts 'ModIfaceCore = ()-  IfaceBackendExts 'ModIfaceFinal = ModIfaceBackend------ | A 'ModIface' plus a 'ModDetails' summarises everything we know--- about a compiled module.  The 'ModIface' is the stuff *before* linking,--- and can be written out to an interface file. The 'ModDetails is after--- linking and can be completely recovered from just the 'ModIface'.------ When we read an interface file, we also construct a 'ModIface' from it,--- except that we explicitly make the 'mi_decls' and a few other fields empty;--- as when reading we consolidate the declarations etc. into a number of indexed--- maps and environments in the 'ExternalPackageState'.-data ModIface_ (phase :: ModIfacePhase)-  = ModIface {-        mi_module     :: !Module,             -- ^ Name of the module we are for-        mi_sig_of     :: !(Maybe Module),     -- ^ Are we a sig of another mod?--        mi_hsc_src    :: !HscSource,          -- ^ Boot? Signature?--        mi_deps     :: Dependencies,-                -- ^ The dependencies of the module.  This is-                -- consulted for directly-imported modules, but not-                -- for anything else (hence lazy)--        mi_usages   :: [Usage],-                -- ^ Usages; kept sorted so that it's easy to decide-                -- whether to write a new iface file (changing usages-                -- doesn't affect the hash of this module)-                -- NOT STRICT!  we read this field lazily from the interface file-                -- It is *only* consulted by the recompilation checker--        mi_exports  :: ![IfaceExport],-                -- ^ Exports-                -- Kept sorted by (mod,occ), to make version comparisons easier-                -- Records the modules that are the declaration points for things-                -- exported by this module, and the 'OccName's of those things---        mi_used_th  :: !Bool,-                -- ^ Module required TH splices when it was compiled.-                -- This disables recompilation avoidance (see #481).--        mi_fixities :: [(OccName,Fixity)],-                -- ^ Fixities-                -- NOT STRICT!  we read this field lazily from the interface file--        mi_warns    :: Warnings,-                -- ^ Warnings-                -- NOT STRICT!  we read this field lazily from the interface file--        mi_anns     :: [IfaceAnnotation],-                -- ^ Annotations-                -- NOT STRICT!  we read this field lazily from the interface file---        mi_decls    :: [IfaceDeclExts phase],-                -- ^ Type, class and variable declarations-                -- The hash of an Id changes if its fixity or deprecations change-                --      (as well as its type of course)-                -- Ditto data constructors, class operations, except that-                -- the hash of the parent class/tycon changes--        mi_globals  :: !(Maybe GlobalRdrEnv),-                -- ^ Binds all the things defined at the top level in-                -- the /original source/ code for this module. which-                -- is NOT the same as mi_exports, nor mi_decls (which-                -- may contains declarations for things not actually-                -- defined by the user).  Used for GHCi and for inspecting-                -- the contents of modules via the GHC API only.-                ---                -- (We need the source file to figure out the-                -- top-level environment, if we didn't compile this module-                -- from source then this field contains @Nothing@).-                ---                -- Strictly speaking this field should live in the-                -- 'HomeModInfo', but that leads to more plumbing.--                -- Instance declarations and rules-        mi_insts       :: [IfaceClsInst],     -- ^ Sorted class instance-        mi_fam_insts   :: [IfaceFamInst],  -- ^ Sorted family instances-        mi_rules       :: [IfaceRule],     -- ^ Sorted rules--        mi_hpc       :: !AnyHpcUsage,-                -- ^ True if this program uses Hpc at any point in the program.--        mi_trust     :: !IfaceTrustInfo,-                -- ^ Safe Haskell Trust information for this module.--        mi_trust_pkg :: !Bool,-                -- ^ Do we require the package this module resides in be trusted-                -- to trust this module? This is used for the situation where a-                -- module is Safe (so doesn't require the package be trusted-                -- itself) but imports some trustworthy modules from its own-                -- package (which does require its own package be trusted).-                -- See Note [Trust Own Package] in GHC.Rename.Names-        mi_complete_sigs :: [IfaceCompleteMatch],--        mi_doc_hdr :: Maybe HsDocString,-                -- ^ Module header.--        mi_decl_docs :: DeclDocMap,-                -- ^ Docs on declarations.--        mi_arg_docs :: ArgDocMap,-                -- ^ Docs on arguments.--        mi_final_exts :: !(IfaceBackendExts phase)-                -- ^ Either `()` or `ModIfaceBackend` for-                -- a fully instantiated interface.-     }---- | Old-style accessor for whether or not the ModIface came from an hs-boot--- file.-mi_boot :: ModIface -> Bool-mi_boot iface = mi_hsc_src iface == HsBootFile---- | Lookups up a (possibly cached) fixity from a 'ModIface'. If one cannot be--- found, 'defaultFixity' is returned instead.-mi_fix :: ModIface -> OccName -> Fixity-mi_fix iface name = mi_fix_fn (mi_final_exts iface) name `orElse` defaultFixity---- | The semantic module for this interface; e.g., if it's a interface--- for a signature, if 'mi_module' is @p[A=<A>]:A@, 'mi_semantic_module'--- will be @<A>@.-mi_semantic_module :: ModIface_ a -> Module-mi_semantic_module iface = case mi_sig_of iface of-                            Nothing -> mi_module iface-                            Just mod -> mod---- | The "precise" free holes, e.g., the signatures that this--- 'ModIface' depends on.-mi_free_holes :: ModIface -> UniqDSet ModuleName-mi_free_holes iface =-  case splitModuleInsts (mi_module iface) of-    (_, Just indef)-        -- A mini-hack: we rely on the fact that 'renameFreeHoles'-        -- drops things that aren't holes.-        -> renameFreeHoles (mkUniqDSet cands) (indefUnitIdInsts (indefModuleUnitId indef))-    _   -> emptyUniqDSet-  where-    cands = map fst (dep_mods (mi_deps iface))---- | Given a set of free holes, and a unit identifier, rename--- the free holes according to the instantiation of the unit--- identifier.  For example, if we have A and B free, and--- our unit identity is @p[A=<C>,B=impl:B]@, the renamed free--- holes are just C.-renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName-renameFreeHoles fhs insts =-    unionManyUniqDSets (map lookup_impl (uniqDSetToList fhs))-  where-    hmap = listToUFM insts-    lookup_impl mod_name-        | Just mod <- lookupUFM hmap mod_name = moduleFreeHoles mod-        -- It wasn't actually a hole-        | otherwise                           = emptyUniqDSet--instance Binary ModIface where-   put_ bh (ModIface {-                 mi_module    = mod,-                 mi_sig_of    = sig_of,-                 mi_hsc_src   = hsc_src,-                 mi_deps      = deps,-                 mi_usages    = usages,-                 mi_exports   = exports,-                 mi_used_th   = used_th,-                 mi_fixities  = fixities,-                 mi_warns     = warns,-                 mi_anns      = anns,-                 mi_decls     = decls,-                 mi_insts     = insts,-                 mi_fam_insts = fam_insts,-                 mi_rules     = rules,-                 mi_hpc       = hpc_info,-                 mi_trust     = trust,-                 mi_trust_pkg = trust_pkg,-                 mi_complete_sigs = complete_sigs,-                 mi_doc_hdr   = doc_hdr,-                 mi_decl_docs = decl_docs,-                 mi_arg_docs  = arg_docs,-                 mi_final_exts = ModIfaceBackend {-                   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_plugin_hash = plugin_hash,-                   mi_orphan = orphan,-                   mi_finsts = hasFamInsts,-                   mi_exp_hash = exp_hash,-                   mi_orphan_hash = orphan_hash-                 }}) = do-        put_ bh mod-        put_ bh sig_of-        put_ bh hsc_src-        put_ bh iface_hash-        put_ bh mod_hash-        put_ bh flag_hash-        put_ bh opt_hash-        put_ bh hpc_hash-        put_ bh plugin_hash-        put_ bh orphan-        put_ bh hasFamInsts-        lazyPut bh deps-        lazyPut bh usages-        put_ bh exports-        put_ bh exp_hash-        put_ bh used_th-        put_ bh fixities-        lazyPut bh warns-        lazyPut bh anns-        put_ bh decls-        put_ bh insts-        put_ bh fam_insts-        lazyPut bh rules-        put_ bh orphan_hash-        put_ bh hpc_info-        put_ bh trust-        put_ bh trust_pkg-        put_ bh complete_sigs-        lazyPut bh doc_hdr-        lazyPut bh decl_docs-        lazyPut bh arg_docs--   get bh = do-        mod         <- get bh-        sig_of      <- get bh-        hsc_src     <- get bh-        iface_hash  <- get bh-        mod_hash    <- get bh-        flag_hash   <- get bh-        opt_hash    <- get bh-        hpc_hash    <- get bh-        plugin_hash <- get bh-        orphan      <- get bh-        hasFamInsts <- get bh-        deps        <- lazyGet bh-        usages      <- {-# SCC "bin_usages" #-} lazyGet bh-        exports     <- {-# SCC "bin_exports" #-} get bh-        exp_hash    <- get bh-        used_th     <- get bh-        fixities    <- {-# SCC "bin_fixities" #-} get bh-        warns       <- {-# SCC "bin_warns" #-} lazyGet bh-        anns        <- {-# SCC "bin_anns" #-} lazyGet bh-        decls       <- {-# SCC "bin_tycldecls" #-} get bh-        insts       <- {-# SCC "bin_insts" #-} get bh-        fam_insts   <- {-# SCC "bin_fam_insts" #-} get bh-        rules       <- {-# SCC "bin_rules" #-} lazyGet bh-        orphan_hash <- get bh-        hpc_info    <- get bh-        trust       <- get bh-        trust_pkg   <- get bh-        complete_sigs <- get bh-        doc_hdr     <- lazyGet bh-        decl_docs   <- lazyGet bh-        arg_docs    <- lazyGet bh-        return (ModIface {-                 mi_module      = mod,-                 mi_sig_of      = sig_of,-                 mi_hsc_src     = hsc_src,-                 mi_deps        = deps,-                 mi_usages      = usages,-                 mi_exports     = exports,-                 mi_used_th     = used_th,-                 mi_anns        = anns,-                 mi_fixities    = fixities,-                 mi_warns       = warns,-                 mi_decls       = decls,-                 mi_globals     = Nothing,-                 mi_insts       = insts,-                 mi_fam_insts   = fam_insts,-                 mi_rules       = rules,-                 mi_hpc         = hpc_info,-                 mi_trust       = trust,-                 mi_trust_pkg   = trust_pkg,-                        -- And build the cached values-                 mi_complete_sigs = complete_sigs,-                 mi_doc_hdr     = doc_hdr,-                 mi_decl_docs   = decl_docs,-                 mi_arg_docs    = arg_docs,-                 mi_final_exts = ModIfaceBackend {-                   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_plugin_hash = plugin_hash,-                   mi_orphan = orphan,-                   mi_finsts = hasFamInsts,-                   mi_exp_hash = exp_hash,-                   mi_orphan_hash = orphan_hash,-                   mi_warn_fn = mkIfaceWarnCache warns,-                   mi_fix_fn = mkIfaceFixCache fixities,-                   mi_hash_fn = mkIfaceHashCache decls-                 }})---- | The original names declared of a certain module that are exported-type IfaceExport = AvailInfo--emptyPartialModIface :: Module -> PartialModIface-emptyPartialModIface mod-  = ModIface { mi_module      = mod,-               mi_sig_of      = Nothing,-               mi_hsc_src     = HsSrcFile,-               mi_deps        = noDependencies,-               mi_usages      = [],-               mi_exports     = [],-               mi_used_th     = False,-               mi_fixities    = [],-               mi_warns       = NoWarnings,-               mi_anns        = [],-               mi_insts       = [],-               mi_fam_insts   = [],-               mi_rules       = [],-               mi_decls       = [],-               mi_globals     = Nothing,-               mi_hpc         = False,-               mi_trust       = noIfaceTrustInfo,-               mi_trust_pkg   = False,-               mi_complete_sigs = [],-               mi_doc_hdr     = Nothing,-               mi_decl_docs   = emptyDeclDocMap,-               mi_arg_docs    = emptyArgDocMap,-               mi_final_exts        = () }--emptyFullModIface :: Module -> ModIface-emptyFullModIface mod =-    (emptyPartialModIface mod)-      { mi_decls = []-      , mi_final_exts = ModIfaceBackend-        { mi_iface_hash = fingerprint0,-          mi_mod_hash = fingerprint0,-          mi_flag_hash = fingerprint0,-          mi_opt_hash = fingerprint0,-          mi_hpc_hash = fingerprint0,-          mi_plugin_hash = fingerprint0,-          mi_orphan = False,-          mi_finsts = False,-          mi_exp_hash = fingerprint0,-          mi_orphan_hash = fingerprint0,-          mi_warn_fn = emptyIfaceWarnCache,-          mi_fix_fn = emptyIfaceFixCache,-          mi_hash_fn = emptyIfaceHashCache } }---- | Constructs cache for the 'mi_hash_fn' field of a 'ModIface'-mkIfaceHashCache :: [(Fingerprint,IfaceDecl)]-                 -> (OccName -> Maybe (OccName, Fingerprint))-mkIfaceHashCache pairs-  = \occ -> lookupOccEnv env occ-  where-    env = foldl' add_decl emptyOccEnv pairs-    add_decl env0 (v,d) = foldl' add env0 (ifaceDeclFingerprints v d)-      where-        add env0 (occ,hash) = extendOccEnv env0 occ (occ,hash)--emptyIfaceHashCache :: OccName -> Maybe (OccName, Fingerprint)-emptyIfaceHashCache _occ = Nothing----- | The 'ModDetails' is essentially a cache for information in the 'ModIface'--- for home modules only. Information relating to packages will be loaded into--- global environments in 'ExternalPackageState'.-data ModDetails-  = ModDetails {-        -- The next two fields are created by the typechecker-        md_exports   :: [AvailInfo],-        md_types     :: !TypeEnv,       -- ^ Local type environment for this particular module-                                        -- Includes Ids, TyCons, PatSyns-        md_insts     :: ![ClsInst],     -- ^ 'DFunId's for the instances in this module-        md_fam_insts :: ![FamInst],-        md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules-        md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently-                                        -- they only annotate things also declared in this module-        md_complete_sigs :: [CompleteMatch]-          -- ^ Complete match pragmas for this module-     }---- | Constructs an empty ModDetails-emptyModDetails :: ModDetails-emptyModDetails-  = ModDetails { md_types     = emptyTypeEnv,-                 md_exports   = [],-                 md_insts     = [],-                 md_rules     = [],-                 md_fam_insts = [],-                 md_anns      = [],-                 md_complete_sigs = [] }---- | Records the modules directly imported by a module for extracting e.g.--- usage information, and also to give better error message-type ImportedMods = ModuleEnv [ImportedBy]---- | If a module was "imported" by the user, we associate it with--- more detailed usage information 'ImportedModsVal'; a module--- imported by the system only gets used for usage information.-data ImportedBy-    = ImportedByUser ImportedModsVal-    | ImportedBySystem--importedByUser :: [ImportedBy] -> [ImportedModsVal]-importedByUser (ImportedByUser imv : bys) = imv : importedByUser bys-importedByUser (ImportedBySystem   : bys) =       importedByUser bys-importedByUser [] = []--data ImportedModsVal- = ImportedModsVal {-        imv_name :: ModuleName,          -- ^ The name the module is imported with-        imv_span :: SrcSpan,             -- ^ the source span of the whole import-        imv_is_safe :: IsSafeImport,     -- ^ whether this is a safe import-        imv_is_hiding :: Bool,           -- ^ whether this is an "hiding" import-        imv_all_exports :: !GlobalRdrEnv, -- ^ all the things the module could provide-          -- NB. BangPattern here: otherwise this leaks. (#15111)-        imv_qualified :: Bool            -- ^ whether this is a qualified import-        }---- | A ModGuts is carried through the compiler, accumulating stuff as it goes--- There is only one ModGuts at any time, the one for the module--- being compiled right now.  Once it is compiled, a 'ModIface' and--- 'ModDetails' are extracted and the ModGuts is discarded.-data ModGuts-  = ModGuts {-        mg_module    :: !Module,         -- ^ Module being compiled-        mg_hsc_src   :: HscSource,       -- ^ Whether it's an hs-boot module-        mg_loc       :: SrcSpan,         -- ^ For error messages from inner passes-        mg_exports   :: ![AvailInfo],    -- ^ What it exports-        mg_deps      :: !Dependencies,   -- ^ What it depends on, directly or-                                         -- otherwise-        mg_usages    :: ![Usage],        -- ^ What was used?  Used for interfaces.--        mg_used_th   :: !Bool,           -- ^ Did we run a TH splice?-        mg_rdr_env   :: !GlobalRdrEnv,   -- ^ Top-level lexical environment--        -- These fields all describe the things **declared in this module**-        mg_fix_env   :: !FixityEnv,      -- ^ Fixities declared in this module.-                                         -- Used for creating interface files.-        mg_tcs       :: ![TyCon],        -- ^ TyCons declared in this module-                                         -- (includes TyCons for classes)-        mg_insts     :: ![ClsInst],      -- ^ Class instances declared in this module-        mg_fam_insts :: ![FamInst],-                                         -- ^ Family instances declared in this module-        mg_patsyns   :: ![PatSyn],       -- ^ Pattern synonyms declared in this module-        mg_rules     :: ![CoreRule],     -- ^ Before the core pipeline starts, contains-                                         -- See Note [Overall plumbing for rules] in Rules.hs-        mg_binds     :: !CoreProgram,    -- ^ Bindings for this module-        mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module-        mg_foreign_files :: ![(ForeignSrcLang, FilePath)],-        -- ^ Files to be compiled with the C compiler-        mg_warns     :: !Warnings,       -- ^ Warnings declared in the module-        mg_anns      :: [Annotation],    -- ^ Annotations declared in this module-        mg_complete_sigs :: [CompleteMatch], -- ^ Complete Matches-        mg_hpc_info  :: !HpcInfo,        -- ^ Coverage tick boxes in the module-        mg_modBreaks :: !(Maybe ModBreaks), -- ^ Breakpoints for the module--                        -- The next two fields are unusual, because they give instance-                        -- environments for *all* modules in the home package, including-                        -- this module, rather than for *just* this module.-                        -- Reason: when looking up an instance we don't want to have to-                        --         look at each module in the home package in turn-        mg_inst_env     :: InstEnv,             -- ^ Class instance environment for-                                                -- /home-package/ modules (including this-                                                -- one); c.f. 'tcg_inst_env'-        mg_fam_inst_env :: FamInstEnv,          -- ^ Type-family instance environment for-                                                -- /home-package/ modules (including this-                                                -- one); c.f. 'tcg_fam_inst_env'--        mg_safe_haskell :: SafeHaskellMode,     -- ^ Safe Haskell mode-        mg_trust_pkg    :: Bool,                -- ^ Do we need to trust our-                                                -- own package for Safe Haskell?-                                                -- See Note [Trust Own Package]-                                                -- in GHC.Rename.Names--        mg_doc_hdr       :: !(Maybe HsDocString), -- ^ Module header.-        mg_decl_docs     :: !DeclDocMap,     -- ^ Docs on declarations.-        mg_arg_docs      :: !ArgDocMap       -- ^ Docs on arguments.-    }---- The ModGuts takes on several slightly different forms:------ After simplification, the following fields change slightly:---      mg_rules        Orphan rules only (local ones now attached to binds)---      mg_binds        With rules attached-------------------------------------------------------------- The Tidy pass forks the information about this module:---      * one lot goes to interface file generation (ModIface)---        and later compilations (ModDetails)---      * the other lot goes to code generation (CgGuts)---- | A restricted form of 'ModGuts' for code generation purposes-data CgGuts-  = CgGuts {-        cg_module    :: !Module,-                -- ^ Module being compiled--        cg_tycons    :: [TyCon],-                -- ^ Algebraic data types (including ones that started-                -- life as classes); generate constructors and info-                -- tables. Includes newtypes, just for the benefit of-                -- External Core--        cg_binds     :: CoreProgram,-                -- ^ The tidied main bindings, including-                -- previously-implicit bindings for record and class-                -- selectors, and data constructor wrappers.  But *not*-                -- data constructor workers; reason: we regard them-                -- as part of the code-gen of tycons--        cg_foreign   :: !ForeignStubs,   -- ^ Foreign export stubs-        cg_foreign_files :: ![(ForeignSrcLang, FilePath)],-        cg_dep_pkgs  :: ![InstalledUnitId], -- ^ Dependent packages, used to-                                            -- generate #includes for C code gen-        cg_hpc_info  :: !HpcInfo,           -- ^ Program coverage tick box information-        cg_modBreaks :: !(Maybe ModBreaks), -- ^ Module breakpoints-        cg_spt_entries :: [SptEntry]-                -- ^ Static pointer table entries for static forms defined in-                -- the module.-                -- See Note [Grand plan for static forms] in StaticPtrTable-    }---------------------------------------- | Foreign export stubs-data ForeignStubs-  = NoStubs-      -- ^ We don't have any stubs-  | ForeignStubs SDoc SDoc-      -- ^ There are some stubs. Parameters:-      ---      --  1) Header file prototypes for-      --     "foreign exported" functions-      ---      --  2) C stubs to use when calling-      --     "foreign exported" functions--appendStubC :: ForeignStubs -> SDoc -> ForeignStubs-appendStubC NoStubs            c_code = ForeignStubs empty c_code-appendStubC (ForeignStubs h c) c_code = ForeignStubs h (c $$ c_code)--{--************************************************************************-*                                                                      *-                The interactive context-*                                                                      *-************************************************************************--Note [The interactive package]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Type, class, and value declarations at the command prompt are treated-as if they were defined in modules-   interactive:Ghci1-   interactive:Ghci2-   ...etc...-with each bunch of declarations using a new module, all sharing a-common package 'interactive' (see Module.interactiveUnitId, and-PrelNames.mkInteractiveModule).--This scheme deals well with shadowing.  For example:--   ghci> data T = A-   ghci> data T = B-   ghci> :i A-   data Ghci1.T = A  -- Defined at <interactive>:2:10--Here we must display info about constructor A, but its type T has been-shadowed by the second declaration.  But it has a respectable-qualified name (Ghci1.T), and its source location says where it was-defined.--So the main invariant continues to hold, that in any session an-original name M.T only refers to one unique thing.  (In a previous-iteration both the T's above were called :Interactive.T, albeit with-different uniques, which gave rise to all sorts of trouble.)--The details are a bit tricky though:-- * The field ic_mod_index counts which Ghci module we've got up to.-   It is incremented when extending ic_tythings-- * ic_tythings contains only things from the 'interactive' package.-- * Module from the 'interactive' package (Ghci1, Ghci2 etc) never go-   in the Home Package Table (HPT).  When you say :load, that's when we-   extend the HPT.-- * The 'thisPackage' field of DynFlags is *not* set to 'interactive'.-   It stays as 'main' (or whatever -this-unit-id says), and is the-   package to which :load'ed modules are added to.-- * So how do we arrange that declarations at the command prompt get to-   be in the 'interactive' package?  Simply by setting the tcg_mod-   field of the TcGblEnv to "interactive:Ghci1".  This is done by the-   call to initTc in initTcInteractive, which in turn get the module-   from it 'icInteractiveModule' field of the interactive context.--   The 'thisPackage' field stays as 'main' (or whatever -this-unit-id says.-- * The main trickiness is that the type environment (tcg_type_env) and-   fixity envt (tcg_fix_env), now contain entities from all the-   interactive-package modules (Ghci1, Ghci2, ...) together, rather-   than just a single module as is usually the case.  So you can't use-   "nameIsLocalOrFrom" to decide whether to look in the TcGblEnv vs-   the HPT/PTE.  This is a change, but not a problem provided you-   know.--* However, the tcg_binds, tcg_sigs, tcg_insts, tcg_fam_insts, etc fields-  of the TcGblEnv, which collect "things defined in this module", all-  refer to stuff define in a single GHCi command, *not* all the commands-  so far.--  In contrast, tcg_inst_env, tcg_fam_inst_env, have instances from-  all GhciN modules, which makes sense -- they are all "home package"-  modules.---Note [Interactively-bound Ids in GHCi]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The Ids bound by previous Stmts in GHCi are currently-        a) GlobalIds, with-        b) An External Name, like Ghci4.foo-           See Note [The interactive package] above-        c) A tidied type-- (a) They must be GlobalIds (not LocalIds) otherwise when we come to-     compile an expression using these ids later, the byte code-     generator will consider the occurrences to be free rather than-     global.-- (b) Having an External Name is important because of Note-     [GlobalRdrEnv shadowing] in RdrName-- (c) Their types are tidied. This is important, because :info may ask-     to look at them, and :info expects the things it looks up to have-     tidy types--Where do interactively-bound Ids come from?--  - GHCi REPL Stmts   e.g.-         ghci> let foo x = x+1-    These start with an Internal Name because a Stmt is a local-    construct, so the renamer naturally builds an Internal name for-    each of its binders.  Then in tcRnStmt they are externalised via-    TcRnDriver.externaliseAndTidyId, so they get Names like Ghic4.foo.--  - Ids bound by the debugger etc have Names constructed by-    GHC.Iface.Env.newInteractiveBinder; at the call sites it is followed by-    mkVanillaGlobal or mkVanillaGlobalWithInfo.  So again, they are-    all Global, External.--  - TyCons, Classes, and Ids bound by other top-level declarations in-    GHCi (eg foreign import, record selectors) also get External-    Names, with Ghci9 (or 8, or 7, etc) as the module name.---Note [ic_tythings]-~~~~~~~~~~~~~~~~~~-The ic_tythings field contains-  * The TyThings declared by the user at the command prompt-    (eg Ids, TyCons, Classes)--  * The user-visible Ids that arise from such things, which-    *don't* come from 'implicitTyThings', notably:-       - record selectors-       - class ops-    The implicitTyThings are readily obtained from the TyThings-    but record selectors etc are not--It does *not* contain-  * DFunIds (they can be gotten from ic_instances)-  * CoAxioms (ditto)--See also Note [Interactively-bound Ids in GHCi]--Note [Override identical instances in GHCi]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If you declare a new instance in GHCi that is identical to a previous one,-we simply override the previous one; we don't regard it as overlapping.-e.g.    Prelude> data T = A | B-        Prelude> instance Eq T where ...-        Prelude> instance Eq T where ...   -- This one overrides--It's exactly the same for type-family instances.  See #7102--}---- | Interactive context, recording information about the state of the--- context in which statements are executed in a GHCi session.-data InteractiveContext-  = InteractiveContext {-         ic_dflags     :: DynFlags,-             -- ^ The 'DynFlags' used to evaluate interactive expressions-             -- and statements.--         ic_mod_index :: Int,-             -- ^ Each GHCi stmt or declaration brings some new things into-             -- scope. We give them names like interactive:Ghci9.T,-             -- where the ic_index is the '9'.  The ic_mod_index is-             -- incremented whenever we add something to ic_tythings-             -- See Note [The interactive package]--         ic_imports :: [InteractiveImport],-             -- ^ The GHCi top-level scope (ic_rn_gbl_env) is extended with-             -- these imports-             ---             -- This field is only stored here so that the client-             -- can retrieve it with GHC.getContext. GHC itself doesn't-             -- use it, but does reset it to empty sometimes (such-             -- as before a GHC.load). The context is set with GHC.setContext.--         ic_tythings   :: [TyThing],-             -- ^ TyThings defined by the user, in reverse order of-             -- definition (ie most recent at the front)-             -- See Note [ic_tythings]--         ic_rn_gbl_env :: GlobalRdrEnv,-             -- ^ The cached 'GlobalRdrEnv', built by-             -- 'InteractiveEval.setContext' and updated regularly-             -- It contains everything in scope at the command line,-             -- including everything in ic_tythings--         ic_instances  :: ([ClsInst], [FamInst]),-             -- ^ All instances and family instances created during-             -- this session.  These are grabbed en masse after each-             -- update to be sure that proper overlapping is retained.-             -- That is, rather than re-check the overlapping each-             -- time we update the context, we just take the results-             -- from the instance code that already does that.--         ic_fix_env :: FixityEnv,-            -- ^ Fixities declared in let statements--         ic_default :: Maybe [Type],-             -- ^ The current default types, set by a 'default' declaration--          ic_resume :: [Resume],-             -- ^ The stack of breakpoint contexts--         ic_monad      :: Name,-             -- ^ The monad that GHCi is executing in--         ic_int_print  :: Name,-             -- ^ The function that is used for printing results-             -- of expressions in ghci and -e mode.--         ic_cwd :: Maybe FilePath-             -- virtual CWD of the program-    }--data InteractiveImport-  = IIDecl (ImportDecl GhcPs)-      -- ^ Bring the exports of a particular module-      -- (filtered by an import decl) into scope--  | IIModule ModuleName-      -- ^ Bring into scope the entire top-level envt of-      -- of this module, including the things imported-      -- into it.----- | Constructs an empty InteractiveContext.-emptyInteractiveContext :: DynFlags -> InteractiveContext-emptyInteractiveContext dflags-  = InteractiveContext {-       ic_dflags     = dflags,-       ic_imports    = [],-       ic_rn_gbl_env = emptyGlobalRdrEnv,-       ic_mod_index  = 1,-       ic_tythings   = [],-       ic_instances  = ([],[]),-       ic_fix_env    = emptyNameEnv,-       ic_monad      = ioTyConName,  -- IO monad by default-       ic_int_print  = printName,    -- System.IO.print by default-       ic_default    = Nothing,-       ic_resume     = [],-       ic_cwd        = Nothing }--icInteractiveModule :: InteractiveContext -> Module-icInteractiveModule (InteractiveContext { ic_mod_index = index })-  = mkInteractiveModule index---- | This function returns the list of visible TyThings (useful for--- e.g. showBindings)-icInScopeTTs :: InteractiveContext -> [TyThing]-icInScopeTTs = ic_tythings---- | Get the PrintUnqualified function based on the flags and this InteractiveContext-icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified-icPrintUnqual dflags InteractiveContext{ ic_rn_gbl_env = grenv } =-    mkPrintUnqualified dflags grenv---- | extendInteractiveContext is called with new TyThings recently defined to update the--- InteractiveContext to include them.  Ids are easily removed when shadowed,--- but Classes and TyCons are not.  Some work could be done to determine--- whether they are entirely shadowed, but as you could still have references--- to them (e.g. instances for classes or values of the type for TyCons), it's--- not clear whether removing them is even the appropriate behavior.-extendInteractiveContext :: InteractiveContext-                         -> [TyThing]-                         -> [ClsInst] -> [FamInst]-                         -> Maybe [Type]-                         -> FixityEnv-                         -> InteractiveContext-extendInteractiveContext ictxt new_tythings new_cls_insts new_fam_insts defaults fix_env-  = ictxt { ic_mod_index  = ic_mod_index ictxt + 1-                            -- Always bump this; even instances should create-                            -- a new mod_index (#9426)-          , ic_tythings   = new_tythings ++ old_tythings-          , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings-          , ic_instances  = ( new_cls_insts ++ old_cls_insts-                            , new_fam_insts ++ fam_insts )-                            -- we don't shadow old family instances (#7102),-                            -- so don't need to remove them here-          , ic_default    = defaults-          , ic_fix_env    = fix_env  -- See Note [Fixity declarations in GHCi]-          }-  where-    new_ids = [id | AnId id <- new_tythings]-    old_tythings = filterOut (shadowed_by new_ids) (ic_tythings ictxt)--    -- Discard old instances that have been fully overridden-    -- See Note [Override identical instances in GHCi]-    (cls_insts, fam_insts) = ic_instances ictxt-    old_cls_insts = filterOut (\i -> any (identicalClsInstHead i) new_cls_insts) cls_insts--extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext--- Just a specialised version-extendInteractiveContextWithIds ictxt new_ids-  | null new_ids = ictxt-  | otherwise    = ictxt { ic_mod_index  = ic_mod_index ictxt + 1-                         , ic_tythings   = new_tythings ++ old_tythings-                         , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings }-  where-    new_tythings = map AnId new_ids-    old_tythings = filterOut (shadowed_by new_ids) (ic_tythings ictxt)--shadowed_by :: [Id] -> TyThing -> Bool-shadowed_by ids = shadowed-  where-    shadowed id = getOccName id `elemOccSet` new_occs-    new_occs = mkOccSet (map getOccName ids)--setInteractivePackage :: HscEnv -> HscEnv--- Set the 'thisPackage' DynFlag to 'interactive'-setInteractivePackage hsc_env-   = hsc_env { hsc_dflags = (hsc_dflags hsc_env)-                { thisInstalledUnitId = toInstalledUnitId interactiveUnitId } }--setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext-setInteractivePrintName ic n = ic{ic_int_print = n}--    -- ToDo: should not add Ids to the gbl env here---- | Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing--- later ones, and shadowing existing entries in the GlobalRdrEnv.-icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv-icExtendGblRdrEnv env tythings-  = foldr add env tythings  -- Foldr makes things in the front of-                            -- the list shadow things at the back-  where-    -- One at a time, to ensure each shadows the previous ones-    add thing env-       | is_sub_bndr thing-       = env-       | otherwise-       = foldl' extendGlobalRdrEnv env1 (concatMap localGREsFromAvail avail)-       where-          env1  = shadowNames env (concatMap availNames avail)-          avail = tyThingAvailInfo thing--    -- Ugh! The new_tythings may include record selectors, since they-    -- are not implicit-ids, and must appear in the TypeEnv.  But they-    -- will also be brought into scope by the corresponding (ATyCon-    -- tc).  And we want the latter, because that has the correct-    -- parent (#10520)-    is_sub_bndr (AnId f) = case idDetails f of-                             RecSelId {}  -> True-                             ClassOpId {} -> True-                             _            -> False-    is_sub_bndr _ = False--substInteractiveContext :: InteractiveContext -> TCvSubst -> InteractiveContext-substInteractiveContext ictxt@InteractiveContext{ ic_tythings = tts } subst-  | isEmptyTCvSubst subst = ictxt-  | otherwise             = ictxt { ic_tythings = map subst_ty tts }-  where-    subst_ty (AnId id)-      = AnId $ id `setIdType` substTyAddInScope subst (idType id)-      -- Variables in the interactive context *can* mention free type variables-      -- because of the runtime debugger. Otherwise you'd expect all-      -- variables bound in the interactive context to be closed.-    subst_ty tt-      = tt--instance Outputable InteractiveImport where-  ppr (IIModule m) = char '*' <> ppr m-  ppr (IIDecl d)   = ppr d--{--************************************************************************-*                                                                      *-        Building a PrintUnqualified-*                                                                      *-************************************************************************--Note [Printing original names]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Deciding how to print names is pretty tricky.  We are given a name-P:M.T, where P is the package name, M is the defining module, and T is-the occurrence name, and we have to decide in which form to display-the name given a GlobalRdrEnv describing the current scope.--Ideally we want to display the name in the form in which it is in-scope.  However, the name might not be in scope at all, and that's-where it gets tricky.  Here are the cases:-- 1. T uniquely maps to  P:M.T      --->  "T"      NameUnqual- 2. There is an X for which X.T-       uniquely maps to  P:M.T     --->  "X.T"    NameQual X- 3. There is no binding for "M.T"  --->  "M.T"    NameNotInScope1- 4. Otherwise                      --->  "P:M.T"  NameNotInScope2--(3) and (4) apply when the entity P:M.T is not in the GlobalRdrEnv at-all. In these cases we still want to refer to the name as "M.T", *but*-"M.T" might mean something else in the current scope (e.g. if there's-an "import X as M"), so to avoid confusion we avoid using "M.T" if-there's already a binding for it.  Instead we write P:M.T.--There's one further subtlety: in case (3), what if there are two-things around, P1:M.T and P2:M.T?  Then we don't want to print both of-them as M.T!  However only one of the modules P1:M and P2:M can be-exposed (say P2), so we use M.T for that, and P1:M.T for the other one.-This is handled by the qual_mod component of PrintUnqualified, inside-the (ppr mod) of case (3), in Name.pprModulePrefix--Note [Printing unit ids]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In the old days, original names were tied to PackageIds, which directly-corresponded to the entities that users wrote in Cabal files, and were perfectly-suitable for printing when we need to disambiguate packages.  However, with-UnitId, the situation can be different: if the key is instantiated with-some holes, we should try to give the user some more useful information.--}---- | Creates some functions that work out the best ways to format--- names for the user according to a set of heuristics.-mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified-mkPrintUnqualified dflags env = QueryQualify qual_name-                                             (mkQualModule dflags)-                                             (mkQualPackage dflags)-  where-  qual_name mod occ-        | [gre] <- unqual_gres-        , right_name gre-        = NameUnqual   -- If there's a unique entity that's in scope-                       -- unqualified with 'occ' AND that entity is-                       -- the right one, then we can use the unqualified name--        | [] <- unqual_gres-        , any is_name forceUnqualNames-        , not (isDerivedOccName occ)-        = NameUnqual   -- Don't qualify names that come from modules-                       -- that come with GHC, often appear in error messages,-                       -- but aren't typically in scope. Doing this does not-                       -- cause ambiguity, and it reduces the amount of-                       -- qualification in error messages thus improving-                       -- readability.-                       ---                       -- A motivating example is 'Constraint'. It's often not-                       -- in scope, but printing GHC.Prim.Constraint seems-                       -- overkill.--        | [gre] <- qual_gres-        = NameQual (greQualModName gre)--        | null qual_gres-        = if null (lookupGRE_RdrName (mkRdrQual (moduleName mod) occ) env)-          then NameNotInScope1-          else NameNotInScope2--        | otherwise-        = NameNotInScope1   -- Can happen if 'f' is bound twice in the module-                            -- Eg  f = True; g = 0; f = False-      where-        is_name :: Name -> Bool-        is_name name = ASSERT2( isExternalName name, ppr name )-                       nameModule name == mod && nameOccName name == occ--        forceUnqualNames :: [Name]-        forceUnqualNames =-          map tyConName [ constraintKindTyCon, heqTyCon, coercibleTyCon ]-          ++ [ eqTyConName ]--        right_name gre = nameModule_maybe (gre_name gre) == Just mod--        unqual_gres = lookupGRE_RdrName (mkRdrUnqual occ) env-        qual_gres   = filter right_name (lookupGlobalRdrEnv env occ)--    -- we can mention a module P:M without the P: qualifier iff-    -- "import M" would resolve unambiguously to P:M.  (if P is the-    -- current package we can just assume it is unqualified).---- | Creates a function for formatting modules based on two heuristics:--- (1) if the module is the current module, don't qualify, and (2) if there--- is only one exposed package which exports this module, don't qualify.-mkQualModule :: DynFlags -> QueryQualifyModule-mkQualModule dflags mod-     | moduleUnitId mod == thisPackage dflags = False--     | [(_, pkgconfig)] <- lookup,-       packageConfigId pkgconfig == moduleUnitId mod-        -- this says: we are given a module P:M, is there just one exposed package-        -- that exposes a module M, and is it package P?-     = False--     | otherwise = True-     where lookup = lookupModuleInAllPackages dflags (moduleName mod)---- | Creates a function for formatting packages based on two heuristics:--- (1) don't qualify if the package in question is "main", and (2) only qualify--- with a unit id if the package ID would be ambiguous.-mkQualPackage :: DynFlags -> QueryQualifyPackage-mkQualPackage dflags uid-     | uid == mainUnitId || uid == interactiveUnitId-        -- Skip the lookup if it's main, since it won't be in the package-        -- database!-     = False-     | Just pkgid <- mb_pkgid-     , searchPackageId dflags pkgid `lengthIs` 1-        -- this says: we are given a package pkg-0.1@MMM, are there only one-        -- exposed packages whose package ID is pkg-0.1?-     = False-     | otherwise-     = True-     where mb_pkgid = fmap sourcePackageId (lookupUnit dflags uid)---- | A function which only qualifies package names if necessary; but--- qualifies all other identifiers.-pkgQual :: DynFlags -> PrintUnqualified-pkgQual dflags = alwaysQualify {-        queryQualifyPackage = mkQualPackage dflags-    }--{--************************************************************************-*                                                                      *-                Implicit TyThings-*                                                                      *-************************************************************************--Note [Implicit TyThings]-~~~~~~~~~~~~~~~~~~~~~~~~-  DEFINITION: An "implicit" TyThing is one that does not have its own-  IfaceDecl in an interface file.  Instead, its binding in the type-  environment is created as part of typechecking the IfaceDecl for-  some other thing.--Examples:-  * All DataCons are implicit, because they are generated from the-    IfaceDecl for the data/newtype.  Ditto class methods.--  * Record selectors are *not* implicit, because they get their own-    free-standing IfaceDecl.--  * Associated data/type families are implicit because they are-    included in the IfaceDecl of the parent class.  (NB: the-    IfaceClass decl happens to use IfaceDecl recursively for the-    associated types, but that's irrelevant here.)--  * Dictionary function Ids are not implicit.--  * Axioms for newtypes are implicit (same as above), but axioms-    for data/type family instances are *not* implicit (like DFunIds).--}---- | Determine the 'TyThing's brought into scope by another 'TyThing'--- /other/ than itself. For example, Id's don't have any implicit TyThings--- as they just bring themselves into scope, but classes bring their--- dictionary datatype, type constructor and some selector functions into--- scope, just for a start!---- N.B. the set of TyThings returned here *must* match the set of--- names returned by GHC.Iface.Load.ifaceDeclImplicitBndrs, in the sense that--- TyThing.getOccName should define a bijection between the two lists.--- This invariant is used in GHC.Iface.Load.loadDecl (see note [Tricky iface loop])--- The order of the list does not matter.-implicitTyThings :: TyThing -> [TyThing]-implicitTyThings (AnId _)       = []-implicitTyThings (ACoAxiom _cc) = []-implicitTyThings (ATyCon tc)    = implicitTyConThings tc-implicitTyThings (AConLike cl)  = implicitConLikeThings cl--implicitConLikeThings :: ConLike -> [TyThing]-implicitConLikeThings (RealDataCon dc)-  = dataConImplicitTyThings dc--implicitConLikeThings (PatSynCon {})-  = []  -- Pattern synonyms have no implicit Ids; the wrapper and matcher-        -- are not "implicit"; they are simply new top-level bindings,-        -- and they have their own declaration in an interface file-        -- Unless a record pat syn when there are implicit selectors-        -- They are still not included here as `implicitConLikeThings` is-        -- used by `tcTyClsDecls` whilst pattern synonyms are typed checked-        -- by `tcTopValBinds`.--implicitClassThings :: Class -> [TyThing]-implicitClassThings cl-  = -- Does not include default methods, because those Ids may have-    --    their own pragmas, unfoldings etc, not derived from the Class object--    -- associated types-    --    No recursive call for the classATs, because they-    --    are only the family decls; they have no implicit things-    map ATyCon (classATs cl) ++--    -- superclass and operation selectors-    map AnId (classAllSelIds cl)--implicitTyConThings :: TyCon -> [TyThing]-implicitTyConThings tc-  = class_stuff ++-      -- fields (names of selectors)--      -- (possibly) implicit newtype axioms-      -- or type family axioms-    implicitCoTyCon tc ++--      -- for each data constructor in order,-      --   the constructor, worker, and (possibly) wrapper-    [ thing | dc    <- tyConDataCons tc-            , thing <- AConLike (RealDataCon dc) : dataConImplicitTyThings dc ]-      -- NB. record selectors are *not* implicit, they have fully-fledged-      -- bindings that pass through the compilation pipeline as normal.-  where-    class_stuff = case tyConClass_maybe tc of-        Nothing -> []-        Just cl -> implicitClassThings cl---- For newtypes and closed type families (only) add the implicit coercion tycon-implicitCoTyCon :: TyCon -> [TyThing]-implicitCoTyCon tc-  | Just co <- newTyConCo_maybe tc = [ACoAxiom $ toBranchedAxiom co]-  | Just co <- isClosedSynFamilyTyConWithAxiom_maybe tc-                                   = [ACoAxiom co]-  | otherwise                      = []---- | Returns @True@ if there should be no interface-file declaration--- for this thing on its own: either it is built-in, or it is part--- of some other declaration, or it is generated implicitly by some--- other declaration.-isImplicitTyThing :: TyThing -> Bool-isImplicitTyThing (AConLike cl) = case cl of-                                    RealDataCon {} -> True-                                    PatSynCon {}   -> False-isImplicitTyThing (AnId id)     = isImplicitId id-isImplicitTyThing (ATyCon tc)   = isImplicitTyCon tc-isImplicitTyThing (ACoAxiom ax) = isImplicitCoAxiom ax---- | tyThingParent_maybe x returns (Just p)--- when pprTyThingInContext should print a declaration for p--- (albeit with some "..." in it) when asked to show x--- It returns the *immediate* parent.  So a datacon returns its tycon--- but the tycon could be the associated type of a class, so it in turn--- might have a parent.-tyThingParent_maybe :: TyThing -> Maybe TyThing-tyThingParent_maybe (AConLike cl) = case cl of-    RealDataCon dc  -> Just (ATyCon (dataConTyCon dc))-    PatSynCon{}     -> Nothing-tyThingParent_maybe (ATyCon tc)   = case tyConAssoc_maybe tc of-                                      Just tc -> Just (ATyCon tc)-                                      Nothing -> Nothing-tyThingParent_maybe (AnId id)     = case idDetails id of-                                      RecSelId { sel_tycon = RecSelData tc } ->-                                          Just (ATyCon tc)-                                      ClassOpId cls               ->-                                          Just (ATyCon (classTyCon cls))-                                      _other                      -> Nothing-tyThingParent_maybe _other = Nothing--tyThingsTyCoVars :: [TyThing] -> TyCoVarSet-tyThingsTyCoVars tts =-    unionVarSets $ map ttToVarSet tts-    where-        ttToVarSet (AnId id)     = tyCoVarsOfType $ idType id-        ttToVarSet (AConLike cl) = case cl of-            RealDataCon dc  -> tyCoVarsOfType $ dataConRepType dc-            PatSynCon{}     -> emptyVarSet-        ttToVarSet (ATyCon tc)-          = case tyConClass_maybe tc of-              Just cls -> (mkVarSet . fst . classTvsFds) cls-              Nothing  -> tyCoVarsOfType $ tyConKind tc-        ttToVarSet (ACoAxiom _)  = emptyVarSet---- | The Names that a TyThing should bring into scope.  Used to build--- the GlobalRdrEnv for the InteractiveContext.-tyThingAvailInfo :: TyThing -> [AvailInfo]-tyThingAvailInfo (ATyCon t)-   = case tyConClass_maybe t of-        Just c  -> [AvailTC n (n : map getName (classMethods c)-                                 ++ map getName (classATs c))-                             [] ]-             where n = getName c-        Nothing -> [AvailTC n (n : map getName dcs) flds]-             where n    = getName t-                   dcs  = tyConDataCons t-                   flds = tyConFieldLabels t-tyThingAvailInfo (AConLike (PatSynCon p))-  = map avail ((getName p) : map flSelector (patSynFieldLabels p))-tyThingAvailInfo t-   = [avail (getName t)]--{--************************************************************************-*                                                                      *-                TypeEnv-*                                                                      *-************************************************************************--}---- | A map from 'Name's to 'TyThing's, constructed by typechecking--- local declarations or interface files-type TypeEnv = NameEnv TyThing--emptyTypeEnv    :: TypeEnv-typeEnvElts     :: TypeEnv -> [TyThing]-typeEnvTyCons   :: TypeEnv -> [TyCon]-typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]-typeEnvIds      :: TypeEnv -> [Id]-typeEnvPatSyns  :: TypeEnv -> [PatSyn]-typeEnvDataCons :: TypeEnv -> [DataCon]-typeEnvClasses  :: TypeEnv -> [Class]-lookupTypeEnv   :: TypeEnv -> Name -> Maybe TyThing--emptyTypeEnv        = emptyNameEnv-typeEnvElts     env = nameEnvElts env-typeEnvTyCons   env = [tc | ATyCon tc   <- typeEnvElts env]-typeEnvCoAxioms env = [ax | ACoAxiom ax <- typeEnvElts env]-typeEnvIds      env = [id | AnId id     <- typeEnvElts env]-typeEnvPatSyns  env = [ps | AConLike (PatSynCon ps) <- typeEnvElts env]-typeEnvDataCons env = [dc | AConLike (RealDataCon dc) <- typeEnvElts env]-typeEnvClasses  env = [cl | tc <- typeEnvTyCons env,-                            Just cl <- [tyConClass_maybe tc]]--mkTypeEnv :: [TyThing] -> TypeEnv-mkTypeEnv things = extendTypeEnvList emptyTypeEnv things--mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv-mkTypeEnvWithImplicits things =-  mkTypeEnv things-    `plusNameEnv`-  mkTypeEnv (concatMap implicitTyThings things)--typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv-typeEnvFromEntities ids tcs famInsts =-  mkTypeEnv (   map AnId ids-             ++ map ATyCon all_tcs-             ++ concatMap implicitTyConThings all_tcs-             ++ map (ACoAxiom . toBranchedAxiom . famInstAxiom) famInsts-            )- where-  all_tcs = tcs ++ famInstsRepTyCons famInsts--lookupTypeEnv = lookupNameEnv---- Extend the type environment-extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv-extendTypeEnv env thing = extendNameEnv env (getName thing) thing--extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv-extendTypeEnvList env things = foldl' extendTypeEnv env things--extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv-extendTypeEnvWithIds env ids-  = extendNameEnvList env [(getName id, AnId id) | id <- ids]--plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv-plusTypeEnv env1 env2 = plusNameEnv env1 env2---- | Find the 'TyThing' for the given 'Name' by using all the resources--- at our disposal: the compiled modules in the 'HomePackageTable' and the--- compiled modules in other packages that live in 'PackageTypeEnv'. Note--- that this does NOT look up the 'TyThing' in the module being compiled: you--- have to do that yourself, if desired-lookupType :: DynFlags-           -> HomePackageTable-           -> PackageTypeEnv-           -> Name-           -> Maybe TyThing--lookupType dflags hpt pte name-  | isOneShot (ghcMode dflags)  -- in one-shot, we don't use the HPT-  = lookupNameEnv pte name-  | otherwise-  = case lookupHptByModule hpt mod of-       Just hm -> lookupNameEnv (md_types (hm_details hm)) name-       Nothing -> lookupNameEnv pte name-  where-    mod = ASSERT2( isExternalName name, ppr name )-          if isHoleName name-            then mkModule (thisPackage dflags) (moduleName (nameModule name))-            else nameModule name---- | As 'lookupType', but with a marginally easier-to-use interface--- if you have a 'HscEnv'-lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)-lookupTypeHscEnv hsc_env name = do-    eps <- readIORef (hsc_EPS hsc_env)-    return $! lookupType dflags hpt (eps_PTE eps) name-  where-    dflags = hsc_dflags hsc_env-    hpt = hsc_HPT hsc_env---- | Get the 'TyCon' from a 'TyThing' if it is a type constructor thing. Panics otherwise-tyThingTyCon :: TyThing -> TyCon-tyThingTyCon (ATyCon tc) = tc-tyThingTyCon other       = pprPanic "tyThingTyCon" (ppr other)---- | Get the 'CoAxiom' from a 'TyThing' if it is a coercion axiom thing. Panics otherwise-tyThingCoAxiom :: TyThing -> CoAxiom Branched-tyThingCoAxiom (ACoAxiom ax) = ax-tyThingCoAxiom other         = pprPanic "tyThingCoAxiom" (ppr other)---- | Get the 'DataCon' from a 'TyThing' if it is a data constructor thing. Panics otherwise-tyThingDataCon :: TyThing -> DataCon-tyThingDataCon (AConLike (RealDataCon dc)) = dc-tyThingDataCon other                       = pprPanic "tyThingDataCon" (ppr other)---- | Get the 'ConLike' from a 'TyThing' if it is a data constructor thing.--- Panics otherwise-tyThingConLike :: TyThing -> ConLike-tyThingConLike (AConLike dc) = dc-tyThingConLike other         = pprPanic "tyThingConLike" (ppr other)---- | Get the 'Id' from a 'TyThing' if it is a id *or* data constructor thing. Panics otherwise-tyThingId :: TyThing -> Id-tyThingId (AnId id)                   = id-tyThingId (AConLike (RealDataCon dc)) = dataConWrapId dc-tyThingId other                       = pprPanic "tyThingId" (ppr other)--{--************************************************************************-*                                                                      *-\subsection{MonadThings and friends}-*                                                                      *-************************************************************************--}---- | Class that abstracts out the common ability of the monads in GHC--- to lookup a 'TyThing' in the monadic environment by 'Name'. Provides--- a number of related convenience functions for accessing particular--- kinds of 'TyThing'-class Monad m => MonadThings m where-        lookupThing :: Name -> m TyThing--        lookupId :: Name -> m Id-        lookupId = liftM tyThingId . lookupThing--        lookupDataCon :: Name -> m DataCon-        lookupDataCon = liftM tyThingDataCon . lookupThing--        lookupTyCon :: Name -> m TyCon-        lookupTyCon = liftM tyThingTyCon . lookupThing---- Instance used in DsMeta-instance MonadThings m => MonadThings (ReaderT s m) where-  lookupThing = lift . lookupThing--{--************************************************************************-*                                                                      *-\subsection{Auxiliary types}-*                                                                      *-************************************************************************--These types are defined here because they are mentioned in ModDetails,-but they are mostly elaborated elsewhere--}-------------------- Warnings ---------------------------- | Warning information for a module-data Warnings-  = NoWarnings                          -- ^ Nothing deprecated-  | WarnAll WarningTxt                  -- ^ Whole module deprecated-  | WarnSome [(OccName,WarningTxt)]     -- ^ Some specific things deprecated--     -- Only an OccName is needed because-     --    (1) a deprecation always applies to a binding-     --        defined in the module in which the deprecation appears.-     --    (2) deprecations are only reported outside the defining module.-     --        this is important because, otherwise, if we saw something like-     ---     --        {-# DEPRECATED f "" #-}-     --        f = ...-     --        h = f-     --        g = let f = undefined in f-     ---     --        we'd need more information than an OccName to know to say something-     --        about the use of f in h but not the use of the locally bound f in g-     ---     --        however, because we only report about deprecations from the outside,-     --        and a module can only export one value called f,-     --        an OccName suffices.-     ---     --        this is in contrast with fixity declarations, where we need to map-     --        a Name to its fixity declaration.-  deriving( Eq )--instance Binary Warnings where-    put_ bh NoWarnings     = putByte bh 0-    put_ bh (WarnAll t) = do-            putByte bh 1-            put_ bh t-    put_ bh (WarnSome ts) = do-            putByte bh 2-            put_ bh ts--    get bh = do-            h <- getByte bh-            case h of-              0 -> return NoWarnings-              1 -> do aa <- get bh-                      return (WarnAll aa)-              _ -> do aa <- get bh-                      return (WarnSome aa)---- | Constructs the cache for the 'mi_warn_fn' field of a 'ModIface'-mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt-mkIfaceWarnCache NoWarnings  = \_ -> Nothing-mkIfaceWarnCache (WarnAll t) = \_ -> Just t-mkIfaceWarnCache (WarnSome pairs) = lookupOccEnv (mkOccEnv pairs)--emptyIfaceWarnCache :: OccName -> Maybe WarningTxt-emptyIfaceWarnCache _ = Nothing--plusWarns :: Warnings -> Warnings -> Warnings-plusWarns d NoWarnings = d-plusWarns NoWarnings d = d-plusWarns _ (WarnAll t) = WarnAll t-plusWarns (WarnAll t) _ = WarnAll t-plusWarns (WarnSome v1) (WarnSome v2) = WarnSome (v1 ++ v2)---- | Creates cached lookup for the 'mi_fix_fn' field of 'ModIface'-mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity-mkIfaceFixCache pairs-  = \n -> lookupOccEnv env n-  where-   env = mkOccEnv pairs--emptyIfaceFixCache :: OccName -> Maybe Fixity-emptyIfaceFixCache _ = Nothing---- | Fixity environment mapping names to their fixities-type FixityEnv = NameEnv FixItem---- | Fixity information for an 'Name'. We keep the OccName in the range--- so that we can generate an interface from it-data FixItem = FixItem OccName Fixity--instance Outputable FixItem where-  ppr (FixItem occ fix) = ppr fix <+> ppr occ--emptyFixityEnv :: FixityEnv-emptyFixityEnv = emptyNameEnv--lookupFixity :: FixityEnv -> Name -> Fixity-lookupFixity env n = case lookupNameEnv env n of-                        Just (FixItem _ fix) -> fix-                        Nothing         -> defaultFixity--{--************************************************************************-*                                                                      *-\subsection{WhatsImported}-*                                                                      *-************************************************************************--}---- | Records whether a module has orphans. An \"orphan\" is one of:------ * An instance declaration in a module other than the definition---   module for one of the type constructors or classes in the instance head------ * A transformation rule in a module other than the one defining---   the function in the head of the rule----type WhetherHasOrphans   = Bool---- | Does this module define family instances?-type WhetherHasFamInst = Bool---- | Did this module originate from a *-boot file?-type IsBootInterface = Bool---- | Dependency information about ALL modules and packages below this one--- in the import hierarchy.------ Invariant: the dependencies of a module @M@ never includes @M@.------ Invariant: none of the lists contain duplicates.-data Dependencies-  = Deps { dep_mods   :: [(ModuleName, IsBootInterface)]-                        -- ^ All home-package modules transitively below this one-                        -- I.e. modules that this one imports, or that are in the-                        --      dep_mods of those directly-imported modules--         , dep_pkgs   :: [(InstalledUnitId, Bool)]-                        -- ^ All packages transitively below this module-                        -- I.e. packages to which this module's direct imports belong,-                        --      or that are in the dep_pkgs of those modules-                        -- The bool indicates if the package is required to be-                        -- trusted when the module is imported as a safe import-                        -- (Safe Haskell). See Note [Tracking Trust Transitively] in GHC.Rename.Names--         , dep_orphs  :: [Module]-                        -- ^ Transitive closure of orphan modules (whether-                        -- home or external pkg).-                        ---                        -- (Possible optimization: don't include family-                        -- instance orphans as they are anyway included in-                        -- 'dep_finsts'.  But then be careful about code-                        -- which relies on dep_orphs having the complete list!)-                        -- This does NOT include us, unlike 'imp_orphs'.--         , dep_finsts :: [Module]-                        -- ^ Transitive closure of depended upon modules which-                        -- contain family instances (whether home or external).-                        -- This is used by 'checkFamInstConsistency'.  This-                        -- does NOT include us, unlike 'imp_finsts'. See Note-                        -- [The type family instance consistency story].--         , dep_plgins :: [ModuleName]-                        -- ^ All the plugins used while compiling this module.-         }-  deriving( Eq )-        -- Equality used only for old/new comparison in GHC.Iface.Utils.addFingerprints-        -- See 'TcRnTypes.ImportAvails' for details on dependencies.--instance Binary Dependencies where-    put_ bh deps = do put_ bh (dep_mods deps)-                      put_ bh (dep_pkgs deps)-                      put_ bh (dep_orphs deps)-                      put_ bh (dep_finsts deps)-                      put_ bh (dep_plgins deps)--    get bh = do ms <- get bh-                ps <- get bh-                os <- get bh-                fis <- get bh-                pl <- get bh-                return (Deps { dep_mods = ms, dep_pkgs = ps, dep_orphs = os,-                               dep_finsts = fis, dep_plgins = pl })--noDependencies :: Dependencies-noDependencies = Deps [] [] [] [] []---- | Records modules for which changes may force recompilation of this module--- See wiki: https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidance------ This differs from Dependencies.  A module X may be in the dep_mods of this--- module (via an import chain) but if we don't use anything from X it won't--- appear in our Usage-data Usage-  -- | Module from another package-  = UsagePackageModule {-        usg_mod      :: Module,-           -- ^ External package module depended on-        usg_mod_hash :: Fingerprint,-            -- ^ Cached module fingerprint-        usg_safe :: IsSafeImport-            -- ^ Was this module imported as a safe import-    }-  -- | Module from the current package-  | UsageHomeModule {-        usg_mod_name :: ModuleName,-            -- ^ Name of the module-        usg_mod_hash :: Fingerprint,-            -- ^ Cached module fingerprint-        usg_entities :: [(OccName,Fingerprint)],-            -- ^ Entities we depend on, sorted by occurrence name and fingerprinted.-            -- NB: usages are for parent names only, e.g. type constructors-            -- but not the associated data constructors.-        usg_exports  :: Maybe Fingerprint,-            -- ^ Fingerprint for the export list of this module,-            -- if we directly imported it (and hence we depend on its export list)-        usg_safe :: IsSafeImport-            -- ^ Was this module imported as a safe import-    }                                           -- ^ Module from the current package-  -- | A file upon which the module depends, e.g. a CPP #include, or using TH's-  -- 'addDependentFile'-  | UsageFile {-        usg_file_path  :: FilePath,-        -- ^ External file dependency. From a CPP #include or TH-        -- addDependentFile. Should be absolute.-        usg_file_hash  :: Fingerprint-        -- ^ 'Fingerprint' of the file contents.--        -- Note: We don't consider things like modification timestamps-        -- here, because there's no reason to recompile if the actual-        -- contents don't change.  This previously lead to odd-        -- recompilation behaviors; see #8114-  }-  -- | A requirement which was merged into this one.-  | UsageMergedRequirement {-        usg_mod :: Module,-        usg_mod_hash :: Fingerprint-  }-    deriving( Eq )-        -- The export list field is (Just v) if we depend on the export list:-        --      i.e. we imported the module directly, whether or not we-        --           enumerated the things we imported, or just imported-        --           everything-        -- We need to recompile if M's exports change, because-        -- if the import was    import M,       we might now have a name clash-        --                                      in the importing module.-        -- if the import was    import M(x)     M might no longer export x-        -- The only way we don't depend on the export list is if we have-        --                      import M()-        -- And of course, for modules that aren't imported directly we don't-        -- depend on their export lists--instance Binary Usage where-    put_ bh usg@UsagePackageModule{} = do-        putByte bh 0-        put_ bh (usg_mod usg)-        put_ bh (usg_mod_hash usg)-        put_ bh (usg_safe     usg)--    put_ bh usg@UsageHomeModule{} = do-        putByte bh 1-        put_ bh (usg_mod_name usg)-        put_ bh (usg_mod_hash usg)-        put_ bh (usg_exports  usg)-        put_ bh (usg_entities usg)-        put_ bh (usg_safe     usg)--    put_ bh usg@UsageFile{} = do-        putByte bh 2-        put_ bh (usg_file_path usg)-        put_ bh (usg_file_hash usg)--    put_ bh usg@UsageMergedRequirement{} = do-        putByte bh 3-        put_ bh (usg_mod      usg)-        put_ bh (usg_mod_hash usg)--    get bh = do-        h <- getByte bh-        case h of-          0 -> do-            nm    <- get bh-            mod   <- get bh-            safe  <- get bh-            return UsagePackageModule { usg_mod = nm, usg_mod_hash = mod, usg_safe = safe }-          1 -> do-            nm    <- get bh-            mod   <- get bh-            exps  <- get bh-            ents  <- get bh-            safe  <- get bh-            return UsageHomeModule { usg_mod_name = nm, usg_mod_hash = mod,-                     usg_exports = exps, usg_entities = ents, usg_safe = safe }-          2 -> do-            fp   <- get bh-            hash <- get bh-            return UsageFile { usg_file_path = fp, usg_file_hash = hash }-          3 -> do-            mod <- get bh-            hash <- get bh-            return UsageMergedRequirement { usg_mod = mod, usg_mod_hash = hash }-          i -> error ("Binary.get(Usage): " ++ show i)--{--************************************************************************-*                                                                      *-                The External Package State-*                                                                      *-************************************************************************--}--type PackageTypeEnv          = TypeEnv-type PackageRuleBase         = RuleBase-type PackageInstEnv          = InstEnv-type PackageFamInstEnv       = FamInstEnv-type PackageAnnEnv           = AnnEnv-type PackageCompleteMatchMap = CompleteMatchMap---- | Information about other packages that we have slurped in by reading--- their interface files-data ExternalPackageState-  = EPS {-        eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface)),-                -- ^ In OneShot mode (only), home-package modules-                -- accumulate in the external package state, and are-                -- sucked in lazily.  For these home-pkg modules-                -- (only) we need to record which are boot modules.-                -- We set this field after loading all the-                -- explicitly-imported interfaces, but before doing-                -- anything else-                ---                -- The 'ModuleName' part is not necessary, but it's useful for-                -- debug prints, and it's convenient because this field comes-                -- direct from 'TcRnTypes.imp_dep_mods'--        eps_PIT :: !PackageIfaceTable,-                -- ^ The 'ModIface's for modules in external packages-                -- whose interfaces we have opened.-                -- The declarations in these interface files are held in the-                -- 'eps_decls', 'eps_inst_env', 'eps_fam_inst_env' and 'eps_rules'-                -- fields of this record, not in the 'mi_decls' fields of the-                -- interface we have sucked in.-                ---                -- What /is/ in the PIT is:-                ---                -- * The Module-                ---                -- * Fingerprint info-                ---                -- * Its exports-                ---                -- * Fixities-                ---                -- * Deprecations and warnings--        eps_free_holes :: InstalledModuleEnv (UniqDSet ModuleName),-                -- ^ Cache for 'mi_free_holes'.  Ordinarily, we can rely on-                -- the 'eps_PIT' for this information, EXCEPT that when-                -- we do dependency analysis, we need to look at the-                -- 'Dependencies' of our imports to determine what their-                -- precise free holes are ('moduleFreeHolesPrecise').  We-                -- don't want to repeatedly reread in the interface-                -- for every import, so cache it here.  When the PIT-                -- gets filled in we can drop these entries.--        eps_PTE :: !PackageTypeEnv,-                -- ^ Result of typechecking all the external package-                -- interface files we have sucked in. The domain of-                -- the mapping is external-package modules--        eps_inst_env     :: !PackageInstEnv,   -- ^ The total 'InstEnv' accumulated-                                               -- from all the external-package modules-        eps_fam_inst_env :: !PackageFamInstEnv,-- ^ The total 'FamInstEnv' accumulated-                                               -- from all the external-package modules-        eps_rule_base    :: !PackageRuleBase,  -- ^ The total 'RuleEnv' accumulated-                                               -- from all the external-package modules-        eps_ann_env      :: !PackageAnnEnv,    -- ^ The total 'AnnEnv' accumulated-                                               -- from all the external-package modules-        eps_complete_matches :: !PackageCompleteMatchMap,-                                  -- ^ The total 'CompleteMatchMap' accumulated-                                  -- from all the external-package modules--        eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv), -- ^ The family instances accumulated from external-                                                         -- packages, keyed off the module that declared them--        eps_stats :: !EpsStats                 -- ^ Stastics about what was loaded from external packages-  }---- | Accumulated statistics about what we are putting into the 'ExternalPackageState'.--- \"In\" means stuff that is just /read/ from interface files,--- \"Out\" means actually sucked in and type-checked-data EpsStats = EpsStats { n_ifaces_in-                         , n_decls_in, n_decls_out-                         , n_rules_in, n_rules_out-                         , n_insts_in, n_insts_out :: !Int }--addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats--- ^ Add stats for one newly-read interface-addEpsInStats stats n_decls n_insts n_rules-  = stats { n_ifaces_in = n_ifaces_in stats + 1-          , n_decls_in  = n_decls_in stats + n_decls-          , n_insts_in  = n_insts_in stats + n_insts-          , n_rules_in  = n_rules_in stats + n_rules }--{--Names in a NameCache are always stored as a Global, and have the SrcLoc-of their binding locations.--Actually that's not quite right.  When we first encounter the original-name, we might not be at its binding site (e.g. we are reading an-interface file); so we give it 'noSrcLoc' then.  Later, when we find-its binding site, we fix it up.--}--updNameCache :: IORef NameCache-             -> (NameCache -> (NameCache, c))  -- The updating function-             -> IO c-updNameCache ncRef upd_fn-  = atomicModifyIORef' ncRef upd_fn--mkSOName :: Platform -> FilePath -> FilePath-mkSOName platform root-    = case platformOS platform of-      OSMinGW32 ->           root  <.> soExt platform-      _         -> ("lib" ++ root) <.> soExt platform--mkHsSOName :: Platform -> FilePath -> FilePath-mkHsSOName platform root = ("lib" ++ root) <.> soExt platform--soExt :: Platform -> FilePath-soExt platform-    = case platformOS platform of-      OSDarwin  -> "dylib"-      OSMinGW32 -> "dll"-      _         -> "so"--{--************************************************************************-*                                                                      *-                The module graph and ModSummary type-        A ModSummary is a node in the compilation manager's-        dependency graph, and it's also passed to hscMain-*                                                                      *-************************************************************************--}---- | A ModuleGraph contains all the nodes from the home package (only).--- There will be a node for each source module, plus a node for each hi-boot--- module.------ The graph is not necessarily stored in topologically-sorted order.  Use--- 'GHC.topSortModuleGraph' and 'Digraph.flattenSCC' to achieve this.-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 = 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:------ * A regular Haskell source module--- * A hi-boot source module----data ModSummary-   = ModSummary {-        ms_mod          :: Module,-          -- ^ Identity of the module-        ms_hsc_src      :: HscSource,-          -- ^ The module source either plain Haskell or hs-boot-        ms_location     :: ModLocation,-          -- ^ Location of the various files belonging to the module-        ms_hs_date      :: UTCTime,-          -- ^ Timestamp of source file-        ms_obj_date     :: Maybe UTCTime,-          -- ^ Timestamp of object, if we have one-        ms_iface_date   :: Maybe UTCTime,-          -- ^ Timestamp of hi file, if we *only* are typechecking (it is-          -- 'Nothing' otherwise.-          -- See Note [Recompilation checking in -fno-code mode] and #9243-        ms_hie_date   :: Maybe UTCTime,-          -- ^ Timestamp of hie file, if we have one-        ms_srcimps      :: [(Maybe FastString, Located ModuleName)],-          -- ^ Source imports of the module-        ms_textual_imps :: [(Maybe FastString, Located ModuleName)],-          -- ^ Non-source imports of the module from the module *text*-        ms_parsed_mod   :: Maybe HsParsedModule,-          -- ^ The parsed, nonrenamed source, if we have it.  This is also-          -- used to support "inline module syntax" in Backpack files.-        ms_hspp_file    :: FilePath,-          -- ^ Filename of preprocessed source file-        ms_hspp_opts    :: DynFlags,-          -- ^ Cached flags from @OPTIONS@, @INCLUDE@ and @LANGUAGE@-          -- pragmas in the modules source code-        ms_hspp_buf     :: Maybe StringBuffer-          -- ^ The actual preprocessed source, if we have it-     }--ms_installed_mod :: ModSummary -> InstalledModule-ms_installed_mod = fst . splitModuleInsts . ms_mod--ms_mod_name :: ModSummary -> ModuleName-ms_mod_name = moduleName . ms_mod--ms_imps :: ModSummary -> [(Maybe FastString, Located ModuleName)]-ms_imps ms =-  ms_textual_imps ms ++-  map mk_additional_import (dynFlagDependencies (ms_hspp_opts ms))-  where-    mk_additional_import mod_nm = (Nothing, noLoc mod_nm)--home_imps :: [(Maybe FastString, Located ModuleName)] -> [Located ModuleName]-home_imps imps = [ lmodname |  (mb_pkg, lmodname) <- imps,-                                  isLocal mb_pkg ]-  where isLocal Nothing = True-        isLocal (Just pkg) | pkg == fsLit "this" = True -- "this" is special-        isLocal _ = False--ms_home_allimps :: ModSummary -> [ModuleName]-ms_home_allimps ms = map unLoc (ms_home_srcimps ms ++ ms_home_imps ms)---- | Like 'ms_home_imps', but for SOURCE imports.-ms_home_srcimps :: ModSummary -> [Located ModuleName]-ms_home_srcimps = home_imps . ms_srcimps---- | All of the (possibly) home module imports from a--- 'ModSummary'; that is to say, each of these module names--- could be a home import if an appropriately named file--- existed.  (This is in contrast to package qualified--- imports, which are guaranteed not to be home imports.)-ms_home_imps :: ModSummary -> [Located ModuleName]-ms_home_imps = home_imps . ms_imps---- The ModLocation contains both the original source filename and the--- filename of the cleaned-up source file after all preprocessing has been--- done.  The point is that the summariser will have to cpp/unlit/whatever--- all files anyway, and there's no point in doing this twice -- just--- park the result in a temp file, put the name of it in the location,--- and let @compile@ read from that file on the way back up.---- The ModLocation is stable over successive up-sweeps in GHCi, wheres--- the ms_hs_date and imports can, of course, change--msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath-msHsFilePath  ms = expectJust "msHsFilePath" (ml_hs_file  (ms_location ms))-msHiFilePath  ms = ml_hi_file  (ms_location ms)-msObjFilePath ms = ml_obj_file (ms_location ms)--msDynObjFilePath :: ModSummary -> DynFlags -> FilePath-msDynObjFilePath ms dflags = dynamicOutputFile dflags (msObjFilePath ms)---- | Did this 'ModSummary' originate from a hs-boot file?-isBootSummary :: ModSummary -> Bool-isBootSummary ms = ms_hsc_src ms == HsBootFile--instance Outputable ModSummary where-   ppr ms-      = sep [text "ModSummary {",-             nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),-                          text "ms_mod =" <+> ppr (ms_mod ms)-                                <> text (hscSourceString (ms_hsc_src ms)) <> comma,-                          text "ms_textual_imps =" <+> ppr (ms_textual_imps ms),-                          text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),-             char '}'-            ]--showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String-showModMsg dflags target recomp mod_summary = showSDoc dflags $-   if gopt Opt_HideSourcePaths dflags-      then text mod_str-      else hsep $-         [ text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' ')-         , char '('-         , text (op $ msHsFilePath mod_summary) <> char ','-         ] ++-         if gopt Opt_BuildDynamicToo dflags-            then [ text obj_file <> char ','-                 , text dyn_file-                 , char ')'-                 ]-            else [ text obj_file, char ')' ]-  where-    op       = normalise-    mod      = moduleName (ms_mod mod_summary)-    mod_str  = showPpr dflags mod ++ hscSourceString (ms_hsc_src mod_summary)-    dyn_file = op $ msDynObjFilePath mod_summary dflags-    obj_file = case target of-                HscInterpreted | recomp -> "interpreted"-                HscNothing              -> "nothing"-                _                       -> (op $ msObjFilePath mod_summary)--{--************************************************************************-*                                                                      *-\subsection{Recompilation}-*                                                                      *-************************************************************************--}---- | Indicates whether a given module's source has been modified since it--- was last compiled.-data SourceModified-  = SourceModified-       -- ^ the source has been modified-  | SourceUnmodified-       -- ^ the source has not been modified.  Compilation may or may-       -- not be necessary, depending on whether any dependencies have-       -- changed since we last compiled.-  | SourceUnmodifiedAndStable-       -- ^ the source has not been modified, and furthermore all of-       -- its (transitive) dependencies are up to date; it definitely-       -- does not need to be recompiled.  This is important for two-       -- reasons: (a) we can omit the version check in checkOldIface,-       -- and (b) if the module used TH splices we don't need to force-       -- recompilation.--{--************************************************************************-*                                                                      *-\subsection{Hpc Support}-*                                                                      *-************************************************************************--}---- | Information about a modules use of Haskell Program Coverage-data HpcInfo-  = HpcInfo-     { hpcInfoTickCount :: Int-     , hpcInfoHash      :: Int-     }-  | NoHpcInfo-     { hpcUsed          :: AnyHpcUsage  -- ^ Is hpc used anywhere on the module \*tree\*?-     }---- | This is used to signal if one of my imports used HPC instrumentation--- even if there is no module-local HPC usage-type AnyHpcUsage = Bool--emptyHpcInfo :: AnyHpcUsage -> HpcInfo-emptyHpcInfo = NoHpcInfo---- | Find out if HPC is used by this module or any of the modules--- it depends upon-isHpcUsed :: HpcInfo -> AnyHpcUsage-isHpcUsed (HpcInfo {})                   = True-isHpcUsed (NoHpcInfo { hpcUsed = used }) = used--{--************************************************************************-*                                                                      *-\subsection{Safe Haskell Support}-*                                                                      *-************************************************************************--This stuff here is related to supporting the Safe Haskell extension,-primarily about storing under what trust type a module has been compiled.--}---- | Is an import a safe import?-type IsSafeImport = Bool---- | Safe Haskell information for 'ModIface'--- Simply a wrapper around SafeHaskellMode to sepperate iface and flags-newtype IfaceTrustInfo = TrustInfo SafeHaskellMode--getSafeMode :: IfaceTrustInfo -> SafeHaskellMode-getSafeMode (TrustInfo x) = x--setSafeMode :: SafeHaskellMode -> IfaceTrustInfo-setSafeMode = TrustInfo--noIfaceTrustInfo :: IfaceTrustInfo-noIfaceTrustInfo = setSafeMode Sf_None--trustInfoToNum :: IfaceTrustInfo -> Word8-trustInfoToNum it-  = case getSafeMode it of-            Sf_None         -> 0-            Sf_Unsafe       -> 1-            Sf_Trustworthy  -> 2-            Sf_Safe         -> 3-            Sf_SafeInferred -> 4-            Sf_Ignore       -> 0--numToTrustInfo :: Word8 -> IfaceTrustInfo-numToTrustInfo 0 = setSafeMode Sf_None-numToTrustInfo 1 = setSafeMode Sf_Unsafe-numToTrustInfo 2 = setSafeMode Sf_Trustworthy-numToTrustInfo 3 = setSafeMode Sf_Safe-numToTrustInfo 4 = setSafeMode Sf_SafeInferred-numToTrustInfo n = error $ "numToTrustInfo: bad input number! (" ++ show n ++ ")"--instance Outputable IfaceTrustInfo where-    ppr (TrustInfo Sf_None)          = text "none"-    ppr (TrustInfo Sf_Ignore)        = text "none"-    ppr (TrustInfo Sf_Unsafe)        = text "unsafe"-    ppr (TrustInfo Sf_Trustworthy)   = text "trustworthy"-    ppr (TrustInfo Sf_Safe)          = text "safe"-    ppr (TrustInfo Sf_SafeInferred)  = text "safe-inferred"--instance Binary IfaceTrustInfo where-    put_ bh iftrust = putByte bh $ trustInfoToNum iftrust-    get bh = getByte bh >>= (return . numToTrustInfo)--{--************************************************************************-*                                                                      *-\subsection{Parser result}-*                                                                      *-************************************************************************--}--data HsParsedModule = HsParsedModule {-    hpm_module    :: Located HsModule,-    hpm_src_files :: [FilePath],-       -- ^ extra source files (e.g. from #includes).  The lexer collects-       -- these from '# <file> <line>' pragmas, which the C preprocessor-       -- leaves behind.  These files and their timestamps are stored in-       -- the .hi file, so that we can force recompilation if any of-       -- them change (#3589)-    hpm_annotations :: ApiAnns-    -- See note [Api annotations] in ApiAnnotation.hs-  }--{--************************************************************************-*                                                                      *-\subsection{Linkable stuff}-*                                                                      *-************************************************************************--This stuff is in here, rather than (say) in Linker.hs, because the Linker.hs-stuff is the *dynamic* linker, and isn't present in a stage-1 compiler--}--isObjectLinkable :: Linkable -> Bool-isObjectLinkable l = not (null unlinked) && all isObject unlinked-  where unlinked = linkableUnlinked l-        -- A linkable with no Unlinked's is treated as a BCO.  We can-        -- generate a linkable with no Unlinked's as a result of-        -- compiling a module in HscNothing mode, and this choice-        -- happens to work well with checkStability in module GHC.--linkableObjs :: Linkable -> [FilePath]-linkableObjs l = [ f | DotO f <- linkableUnlinked l ]------------------------------------------------- | Is this an actual file on disk we can link in somehow?-isObject :: Unlinked -> Bool-isObject (DotO _)   = True-isObject (DotA _)   = True-isObject (DotDLL _) = True-isObject _          = False---- | Is this a bytecode linkable with no file on disk?-isInterpretable :: Unlinked -> Bool-isInterpretable = not . isObject---- | Retrieve the filename of the linkable if possible. Panic if it is a byte-code object-nameOfObject :: Unlinked -> FilePath-nameOfObject (DotO fn)   = fn-nameOfObject (DotA fn)   = fn-nameOfObject (DotDLL fn) = fn-nameOfObject other       = pprPanic "nameOfObject" (ppr other)---- | Retrieve the compiled byte-code if possible. Panic if it is a file-based linkable-byteCodeOfObject :: Unlinked -> CompiledByteCode-byteCodeOfObject (BCOs bc _) = bc-byteCodeOfObject other       = pprPanic "byteCodeOfObject" (ppr other)-------------------------------------------------- | A list of conlikes which represents a complete pattern match.--- These arise from @COMPLETE@ signatures.---- See Note [Implementation of COMPLETE signatures]-data CompleteMatch = CompleteMatch {-                            completeMatchConLikes :: [Name]-                            -- ^ The ConLikes that form a covering family-                            -- (e.g. Nothing, Just)-                          , completeMatchTyCon :: Name-                            -- ^ The TyCon that they cover (e.g. Maybe)-                          }--instance Outputable CompleteMatch where-  ppr (CompleteMatch cl ty) = text "CompleteMatch:" <+> ppr cl-                                                    <+> dcolon <+> ppr ty---- | A map keyed by the 'completeMatchTyCon'.---- See Note [Implementation of COMPLETE signatures]-type CompleteMatchMap = UniqFM [CompleteMatch]--mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap-mkCompleteMatchMap = extendCompleteMatchMap emptyUFM--extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch]-                       -> CompleteMatchMap-extendCompleteMatchMap = foldl' insertMatch-  where-    insertMatch :: CompleteMatchMap -> CompleteMatch -> CompleteMatchMap-    insertMatch ufm c@(CompleteMatch _ t) = addToUFM_C (++) ufm t [c]--{--Note [Implementation of COMPLETE signatures]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A COMPLETE signature represents a set of conlikes (i.e., constructors or-pattern synonyms) such that if they are all pattern-matched against in a-function, it gives rise to a total function. An example is:--  newtype Boolean = Boolean Int-  pattern F, T :: Boolean-  pattern F = Boolean 0-  pattern T = Boolean 1-  {-# COMPLETE F, T #-}--  -- This is a total function-  booleanToInt :: Boolean -> Int-  booleanToInt F = 0-  booleanToInt T = 1--COMPLETE sets are represented internally in GHC with the CompleteMatch data-type. For example, {-# COMPLETE F, T #-} would be represented as:--  CompleteMatch { complateMatchConLikes = [F, T]-                , completeMatchTyCon    = Boolean }--Note that GHC was able to infer the completeMatchTyCon (Boolean), but for the-cases in which it's ambiguous, you can also explicitly specify it in the source-language by writing this:--  {-# COMPLETE F, T :: Boolean #-}--For efficiency purposes, GHC collects all of the CompleteMatches that it knows-about into a CompleteMatchMap, which is a map that is keyed by the-completeMatchTyCon. In other words, you could have a multiple COMPLETE sets-for the same TyCon:--  {-# COMPLETE F, T1 :: Boolean #-}-  {-# COMPLETE F, T2 :: Boolean #-}--And looking up the values in the CompleteMatchMap associated with Boolean-would give you [CompleteMatch [F, T1] Boolean, CompleteMatch [F, T2] Boolean].-dsGetCompleteMatches in DsMeta accomplishes this lookup.--Also see Note [Typechecking Complete Matches] in TcBinds for a more detailed-explanation for how GHC ensures that all the conlikes in a COMPLETE set are-consistent.--}---- | Foreign language of the phase if the phase deals with a foreign code-phaseForeignLanguage :: Phase -> Maybe ForeignSrcLang-phaseForeignLanguage phase = case phase of-  Phase.Cc           -> Just LangC-  Phase.Ccxx         -> Just LangCxx-  Phase.Cobjc        -> Just LangObjc-  Phase.Cobjcxx      -> Just LangObjcxx-  Phase.HCc          -> Just LangC-  Phase.As _         -> Just LangAsm-  Phase.MergeForeign -> Just RawObject-  _                  -> Nothing------------------------------------------------- Take care, this instance only forces to the degree necessary to--- avoid major space leaks.-instance (NFData (IfaceBackendExts (phase :: ModIfacePhase)), NFData (IfaceDeclExts (phase :: ModIfacePhase))) => NFData (ModIface_ phase) where-  rnf (ModIface f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12-                f13 f14 f15 f16 f17 f18 f19 f20 f21 f22 f23) =-    rnf f1 `seq` rnf f2 `seq` f3 `seq` f4 `seq` f5 `seq` f6 `seq` rnf f7 `seq` f8 `seq`-    f9 `seq` rnf f10 `seq` rnf f11 `seq` f12 `seq` rnf f13 `seq` rnf f14 `seq` rnf f15 `seq`-    rnf f16 `seq` f17 `seq` rnf f18 `seq` rnf f19 `seq` f20 `seq` f21 `seq` f22 `seq` rnf f23

− compiler/main/InteractiveEvalTypes.hs

@@ -1,89 +0,0 @@--- ----------------------------------------------------------------------------------- (c) The University of Glasgow, 2005-2007------ Running statements interactively------ -------------------------------------------------------------------------------module InteractiveEvalTypes (-        Resume(..), History(..), ExecResult(..),-        SingleStep(..), isStep, ExecOptions(..),-        BreakInfo(..)-        ) where--import GhcPrelude--import GHCi.RemoteTypes-import GHCi.Message (EvalExpr, ResumeContext)-import Id-import Name-import Module-import RdrName-import Type-import SrcLoc-import Exception--import Data.Word-import GHC.Stack.CCS--data ExecOptions- = ExecOptions-     { execSingleStep :: SingleStep         -- ^ stepping mode-     , execSourceFile :: String             -- ^ filename (for errors)-     , execLineNumber :: Int                -- ^ line number (for errors)-     , execWrap :: ForeignHValue -> EvalExpr ForeignHValue-     }--data SingleStep-   = RunToCompletion-   | SingleStep-   | RunAndLogSteps--isStep :: SingleStep -> Bool-isStep RunToCompletion = False-isStep _ = True--data ExecResult-  = ExecComplete-       { execResult :: Either SomeException [Name]-       , execAllocation :: Word64-       }-  | ExecBreak-       { breakNames :: [Name]-       , breakInfo :: Maybe BreakInfo-       }--data BreakInfo = BreakInfo-  { breakInfo_module :: Module-  , breakInfo_number :: Int-  }--data Resume = Resume-       { resumeStmt      :: String       -- the original statement-       , resumeContext   :: ForeignRef (ResumeContext [HValueRef])-       , resumeBindings  :: ([TyThing], GlobalRdrEnv)-       , resumeFinalIds  :: [Id]         -- [Id] to bind on completion-       , resumeApStack   :: ForeignHValue -- The object from which we can get-                                        -- value of the free variables.-       , resumeBreakInfo :: Maybe BreakInfo-                                        -- the breakpoint we stopped at-                                        -- (module, index)-                                        -- (Nothing <=> exception)-       , resumeSpan      :: SrcSpan      -- just a copy of the SrcSpan-                                        -- from the ModBreaks,-                                        -- otherwise it's a pain to-                                        -- fetch the ModDetails &-                                        -- ModBreaks to get this.-       , resumeDecl      :: String       -- ditto-       , resumeCCS       :: RemotePtr CostCentreStack-       , resumeHistory   :: [History]-       , resumeHistoryIx :: Int           -- 0 <==> at the top of the history-       }--data History-   = History {-        historyApStack   :: ForeignHValue,-        historyBreakInfo :: BreakInfo,-        historyEnclosingDecls :: [String]  -- declarations enclosing the breakpoint-   }

− compiler/main/Packages.hs

@@ -1,2215 +0,0 @@--- (c) The University of Glasgow, 2006--{-# LANGUAGE CPP, ScopedTypeVariables, BangPatterns, FlexibleContexts #-}---- | Package manipulation-module Packages (-        module UnitInfo,--        -- * Reading the package config, and processing cmdline args-        PackageState(preloadPackages, explicitPackages, moduleNameProvidersMap, requirementContext),-        PackageDatabase (..),-        UnitInfoMap,-        emptyPackageState,-        initPackages,-        readPackageDatabases,-        readPackageDatabase,-        getPackageConfRefs,-        resolvePackageDatabase,-        listUnitInfoMap,--        -- * Querying the package config-        lookupUnit,-        lookupUnit',-        lookupInstalledPackage,-        lookupPackageName,-        improveUnitId,-        searchPackageId,-        getPackageDetails,-        getInstalledPackageDetails,-        componentIdString,-        displayInstalledUnitId,-        listVisibleModuleNames,-        lookupModuleInAllPackages,-        lookupModuleWithSuggestions,-        lookupPluginModuleWithSuggestions,-        LookupResult(..),-        ModuleSuggestion(..),-        ModuleOrigin(..),-        UnusablePackageReason(..),-        pprReason,--        -- * Inspecting the set of packages in scope-        getPackageIncludePath,-        getPackageLibraryPath,-        getPackageLinkOpts,-        getPackageExtraCcOpts,-        getPackageFrameworkPath,-        getPackageFrameworks,-        getUnitInfoMap,-        getPreloadPackagesAnd,--        collectArchives,-        collectIncludeDirs, collectLibraryPaths, collectLinkOpts,-        packageHsLibs, getLibs,--        -- * Utils-        unwireUnitId,-        pprFlag,-        pprPackages,-        pprPackagesSimple,-        pprModuleMap,-        isIndefinite,-        isDllName-    )-where--#include "HsVersions.h"--import GhcPrelude--import GHC.PackageDb-import UnitInfo-import DynFlags-import Name             ( Name, nameModule_maybe )-import UniqFM-import UniqDFM-import UniqSet-import Module-import Util-import Panic-import GHC.Platform-import Outputable-import Maybes--import System.Environment ( getEnv )-import FastString-import ErrUtils         ( debugTraceMsg, MsgDoc, dumpIfSet_dyn,-                          withTiming, DumpFormat (..) )-import Exception--import System.Directory-import System.FilePath as FilePath-import qualified System.FilePath.Posix as FilePath.Posix-import Control.Monad-import Data.Graph (stronglyConnComp, SCC(..))-import Data.Char ( toUpper )-import Data.List as List-import Data.Map (Map)-import Data.Set (Set)-import Data.Monoid (First(..))-import qualified Data.Semigroup as Semigroup-import qualified Data.Map as Map-import qualified Data.Map.Strict as MapStrict-import qualified Data.Set as Set-import Data.Version---- ------------------------------------------------------------------------------ The Package state---- | Package state is all stored in 'DynFlags', including the details of--- all packages, which packages are exposed, and which modules they--- provide.------ The package state is computed by 'initPackages', and kept in DynFlags.--- It is influenced by various package flags:------   * @-package <pkg>@ and @-package-id <pkg>@ cause @<pkg>@ to become exposed.---     If @-hide-all-packages@ was not specified, these commands also cause---      all other packages with the same name to become hidden.------   * @-hide-package <pkg>@ causes @<pkg>@ to become hidden.------   * (there are a few more flags, check below for their semantics)------ The package state has the following properties.------   * Let @exposedPackages@ be the set of packages thus exposed.---     Let @depExposedPackages@ be the transitive closure from @exposedPackages@ of---     their dependencies.------   * 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---     from @depExposedPackages@ are valid.------   * When linking in a compilation manager mode, we link in packages the---     program depends on (the compiler knows this list by the---     time it gets to the link step).  Also, we link in all packages---     which were mentioned with preload @-package@ flags on the command-line,---     or are a transitive dependency of same, or are \"base\"\/\"rts\".---     The reason for this is that we might need packages which don't---     contain any Haskell modules, and therefore won't be discovered---     by the normal mechanism of dependency tracking.---- Notes on DLLs--- ~~~~~~~~~~~~~--- When compiling module A, which imports module B, we need to--- know whether B will be in the same DLL as A.---      If it's in the same DLL, we refer to B_f_closure---      If it isn't, we refer to _imp__B_f_closure--- When compiling A, we record in B's Module value whether it's--- in a different DLL, by setting the DLL flag.---- | Given a module name, there may be multiple ways it came into scope,--- possibly simultaneously.  This data type tracks all the possible ways--- it could have come into scope.  Warning: don't use the record functions,--- they're partial!-data ModuleOrigin =-    -- | Module is hidden, and thus never will be available for import.-    -- (But maybe the user didn't realize), so we'll still keep track-    -- of these modules.)-    ModHidden-    -- | Module is unavailable because the package is unusable.-  | ModUnusable UnusablePackageReason-    -- | Module is public, and could have come from some places.-  | ModOrigin {-        -- | @Just False@ means that this module is in-        -- someone's @exported-modules@ list, but that package is hidden;-        -- @Just True@ means that it is available; @Nothing@ means neither-        -- applies.-        fromOrigPackage :: Maybe Bool-        -- | Is the module available from a reexport of an exposed package?-        -- There could be multiple.-      , fromExposedReexport :: [UnitInfo]-        -- | Is the module available from a reexport of a hidden package?-      , fromHiddenReexport :: [UnitInfo]-        -- | Did the module export come from a package flag? (ToDo: track-        -- more information.-      , fromPackageFlag :: Bool-      }--instance Outputable ModuleOrigin where-    ppr ModHidden = text "hidden module"-    ppr (ModUnusable _) = text "unusable module"-    ppr (ModOrigin e res rhs f) = sep (punctuate comma (-        (case e of-            Nothing -> []-            Just False -> [text "hidden package"]-            Just True -> [text "exposed package"]) ++-        (if null res-            then []-            else [text "reexport by" <+>-                    sep (map (ppr . packageConfigId) res)]) ++-        (if null rhs-            then []-            else [text "hidden reexport by" <+>-                    sep (map (ppr . packageConfigId) res)]) ++-        (if f then [text "package flag"] else [])-        ))---- | Smart constructor for a module which is in @exposed-modules@.  Takes--- as an argument whether or not the defining package is exposed.-fromExposedModules :: Bool -> ModuleOrigin-fromExposedModules e = ModOrigin (Just e) [] [] False---- | Smart constructor for a module which is in @reexported-modules@.  Takes--- as an argument whether or not the reexporting package is exposed, and--- also its 'UnitInfo'.-fromReexportedModules :: Bool -> UnitInfo -> ModuleOrigin-fromReexportedModules True pkg = ModOrigin Nothing [pkg] [] False-fromReexportedModules False pkg = ModOrigin Nothing [] [pkg] False---- | Smart constructor for a module which was bound by a package flag.-fromFlag :: ModuleOrigin-fromFlag = ModOrigin Nothing [] [] True--instance Semigroup ModuleOrigin where-    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-    _x <> _y = panic "ModOrigin: hidden module redefined"--instance Monoid ModuleOrigin where-    mempty = ModOrigin Nothing [] [] False-    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?)-originVisible :: ModuleOrigin -> Bool-originVisible ModHidden = False-originVisible (ModUnusable _) = False-originVisible (ModOrigin b res _ f) = b == Just True || not (null res) || f---- | Are there actually no providers for this module?  This will never occur--- except when we're filtering based on package imports.-originEmpty :: ModuleOrigin -> Bool-originEmpty (ModOrigin Nothing [] [] False) = True-originEmpty _ = False---- | 'UniqFM' map from 'InstalledUnitId'-type InstalledUnitIdMap = UniqDFM---- | 'UniqFM' map from 'UnitId' to 'UnitInfo', plus--- the transitive closure of preload packages.-data UnitInfoMap = UnitInfoMap {-        unUnitInfoMap :: InstalledUnitIdMap UnitInfo,-        -- | The set of transitively reachable packages according-        -- to the explicitly provided command line arguments.-        -- See Note [UnitId to InstalledUnitId improvement]-        preloadClosure :: UniqSet InstalledUnitId-    }---- | 'UniqFM' map from 'UnitId' to a 'UnitVisibility'.-type VisibilityMap = Map UnitId UnitVisibility---- | 'UnitVisibility' records the various aspects of visibility of a particular--- 'UnitId'.-data UnitVisibility = UnitVisibility-    { uv_expose_all :: Bool-      --  ^ Should all modules in exposed-modules should be dumped into scope?-    , uv_renamings :: [(ModuleName, ModuleName)]-      -- ^ Any custom renamings that should bring extra 'ModuleName's into-      -- scope.-    , uv_package_name :: First FastString-      -- ^ The package name is associated with the 'UnitId'.  This is used-      -- to implement legacy behavior where @-package foo-0.1@ implicitly-      -- hides any packages named @foo@-    , uv_requirements :: Map ModuleName (Set IndefModule)-      -- ^ The signatures which are contributed to the requirements context-      -- from this unit ID.-    , uv_explicit :: Bool-      -- ^ Whether or not this unit was explicitly brought into scope,-      -- as opposed to implicitly via the 'exposed' fields in the-      -- package database (when @-hide-all-packages@ is not passed.)-    }--instance Outputable UnitVisibility where-    ppr (UnitVisibility {-        uv_expose_all = b,-        uv_renamings = rns,-        uv_package_name = First mb_pn,-        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-             , uv_renamings = []-             , uv_package_name = First Nothing-             , uv_requirements = Map.empty-             , uv_explicit = False-             }-    mappend = (Semigroup.<>)--type WiredUnitId = DefUnitId-type PreloadUnitId = InstalledUnitId---- | Map from 'ModuleName' to a set of of module providers (i.e. a 'Module' and--- its 'ModuleOrigin').------ NB: the set is in fact a 'Map Module ModuleOrigin', probably to keep only one--- origin for a given 'Module'-type ModuleNameProvidersMap =-    Map ModuleName (Map Module ModuleOrigin)--data PackageState = PackageState {-  -- | A mapping of 'UnitId' to 'UnitInfo'.  This list is adjusted-  -- so that only valid packages are here.  'UnitInfo' reflects-  -- what was stored *on disk*, except for the 'trusted' flag, which-  -- is adjusted at runtime.  (In particular, some packages in this map-  -- may have the 'exposed' flag be 'False'.)-  unitInfoMap :: UnitInfoMap,--  -- | A mapping of 'PackageName' to 'ComponentId'.  This is used when-  -- users refer to packages in Backpack includes.-  packageNameMap            :: Map PackageName ComponentId,--  -- | A mapping from wired in names to the original names from the-  -- package database.-  unwireMap :: Map WiredUnitId WiredUnitId,--  -- | The packages we're going to link in eagerly.  This list-  -- should be in reverse dependency order; that is, a package-  -- is always mentioned before the packages it depends on.-  preloadPackages      :: [PreloadUnitId],--  -- | Packages which we explicitly depend on (from a command line flag).-  -- We'll use this to generate version macros.-  explicitPackages      :: [UnitId],--  -- | This is a full map from 'ModuleName' to all modules which may possibly-  -- be providing it.  These providers may be hidden (but we'll still want-  -- to report them in error messages), or it may be an ambiguous import.-  moduleNameProvidersMap    :: !ModuleNameProvidersMap,--  -- | A map, like 'moduleNameProvidersMap', but controlling plugin visibility.-  pluginModuleNameProvidersMap    :: !ModuleNameProvidersMap,--  -- | A map saying, for each requirement, what interfaces must be merged-  -- together when we use them.  For example, if our dependencies-  -- are @p[A=<A>]@ and @q[A=<A>,B=r[C=<A>]:B]@, then the interfaces-  -- to merge for A are @p[A=<A>]:A@, @q[A=<A>,B=r[C=<A>]:B]:A@-  -- and @r[C=<A>]:C@.-  ---  -- There's an entry in this map for each hole in our home library.-  requirementContext :: Map ModuleName [IndefModule]-  }--emptyPackageState :: PackageState-emptyPackageState = PackageState {-    unitInfoMap = emptyUnitInfoMap,-    packageNameMap = Map.empty,-    unwireMap = Map.empty,-    preloadPackages = [],-    explicitPackages = [],-    moduleNameProvidersMap = Map.empty,-    pluginModuleNameProvidersMap = Map.empty,-    requirementContext = Map.empty-    }---- | Package database-data PackageDatabase = PackageDatabase-   { packageDatabasePath  :: FilePath-   , packageDatabaseUnits :: [UnitInfo]-   }--type InstalledPackageIndex = Map InstalledUnitId UnitInfo---- | Empty package configuration map-emptyUnitInfoMap :: UnitInfoMap-emptyUnitInfoMap = UnitInfoMap emptyUDFM emptyUniqSet---- | Find the unit we know about with the given unit id, if any-lookupUnit :: DynFlags -> UnitId -> Maybe UnitInfo-lookupUnit dflags = lookupUnit' (isIndefinite dflags) (unitInfoMap (pkgState dflags))---- | A more specialized interface, which takes a boolean specifying--- whether or not to look for on-the-fly renamed interfaces, and--- just a 'UnitInfoMap' rather than a 'DynFlags' (so it can--- be used while we're initializing 'DynFlags'-lookupUnit' :: Bool -> UnitInfoMap -> UnitId -> Maybe UnitInfo-lookupUnit' False (UnitInfoMap pkg_map _) uid = lookupUDFM pkg_map uid-lookupUnit' True m@(UnitInfoMap pkg_map _) uid =-    case splitUnitIdInsts uid of-        (iuid, Just indef) ->-            fmap (renamePackage m (indefUnitIdInsts indef))-                 (lookupUDFM pkg_map iuid)-        (_, Nothing) -> lookupUDFM pkg_map uid--{---- | Find the indefinite package for a given 'ComponentId'.--- The way this works is just by fiat'ing that every indefinite package's--- unit key is precisely its component ID; and that they share uniques.-lookupComponentId :: DynFlags -> ComponentId -> Maybe UnitInfo-lookupComponentId dflags (ComponentId cid_fs) = lookupUDFM pkg_map cid_fs-  where-    UnitInfoMap pkg_map = unitInfoMap (pkgState dflags)--}---- | Find the package we know about with the given package name (e.g. @foo@), if any--- (NB: there might be a locally defined unit name which overrides this)-lookupPackageName :: DynFlags -> PackageName -> Maybe ComponentId-lookupPackageName dflags n = Map.lookup n (packageNameMap (pkgState dflags))---- | Search for packages with a given package ID (e.g. \"foo-0.1\")-searchPackageId :: DynFlags -> SourcePackageId -> [UnitInfo]-searchPackageId dflags pid = filter ((pid ==) . sourcePackageId)-                               (listUnitInfoMap dflags)---- | Extends the package configuration map with a list of package configs.-extendUnitInfoMap-   :: UnitInfoMap -> [UnitInfo] -> UnitInfoMap-extendUnitInfoMap (UnitInfoMap pkg_map closure) new_pkgs-  = UnitInfoMap (foldl' add pkg_map new_pkgs) closure-    -- We also add the expanded version of the packageConfigId, so that-    -- 'improveUnitId' can find it.-  where add pkg_map p = addToUDFM (addToUDFM pkg_map (expandedUnitInfoId p) p)-                                  (installedUnitInfoId p) p---- | Looks up the package with the given id in the package state, panicing if it is--- not found-getPackageDetails :: HasDebugCallStack => DynFlags -> UnitId -> UnitInfo-getPackageDetails dflags pid =-    case lookupUnit dflags pid of-      Just config -> config-      Nothing -> pprPanic "getPackageDetails" (ppr pid)--lookupInstalledPackage :: DynFlags -> InstalledUnitId -> Maybe UnitInfo-lookupInstalledPackage dflags uid = lookupInstalledPackage' (unitInfoMap (pkgState dflags)) uid--lookupInstalledPackage' :: UnitInfoMap -> InstalledUnitId -> Maybe UnitInfo-lookupInstalledPackage' (UnitInfoMap db _) uid = lookupUDFM db uid--getInstalledPackageDetails :: HasDebugCallStack => DynFlags -> InstalledUnitId -> UnitInfo-getInstalledPackageDetails dflags uid =-    case lookupInstalledPackage dflags uid of-      Just config -> config-      Nothing -> pprPanic "getInstalledPackageDetails" (ppr uid)---- | Get a list of entries from the package database.  NB: be careful with--- this function, although all packages in this map are "visible", this--- does not imply that the exposed-modules of the package are available--- (they may have been thinned or renamed).-listUnitInfoMap :: DynFlags -> [UnitInfo]-listUnitInfoMap dflags = eltsUDFM pkg_map-  where-    UnitInfoMap pkg_map _ = unitInfoMap (pkgState dflags)---- ------------------------------------------------------------------------------- Loading the package db files and building up the package state---- | Read the package database files, and sets up various internal tables of--- package information, according to the package-related flags on the--- command-line (@-package@, @-hide-package@ etc.)------ Returns a list of packages to link in if we're doing dynamic linking.--- This list contains the packages that the user explicitly mentioned with--- @-package@ flags.------ 'initPackages' can be called again subsequently after updating the--- 'packageFlags' field of the 'DynFlags', and it will update the--- 'pkgState' in 'DynFlags' and return a list of packages to--- link in.-initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId])-initPackages dflags = withTiming dflags-                                  (text "initializing package database")-                                  forcePkgDb $ do-  read_pkg_dbs <--    case pkgDatabase dflags of-        Nothing  -> readPackageDatabases dflags-        Just dbs -> return dbs--  let-      distrust_all db = db { packageDatabaseUnits = distrustAllUnits (packageDatabaseUnits db) }--      pkg_dbs-         | gopt Opt_DistrustAllPackages dflags = map distrust_all read_pkg_dbs-         | otherwise                           = read_pkg_dbs--  (pkg_state, preload, insts)-        <- mkPackageState dflags pkg_dbs []-  return (dflags{ pkgDatabase = Just read_pkg_dbs,-                  pkgState = pkg_state,-                  thisUnitIdInsts_ = insts },-          preload)-  where-    forcePkgDb (dflags, _) = unitInfoMap (pkgState dflags) `seq` ()---- -------------------------------------------------------------------------------- Reading the package database(s)--readPackageDatabases :: DynFlags -> IO [PackageDatabase]-readPackageDatabases dflags = do-  conf_refs <- getPackageConfRefs dflags-  confs     <- liftM catMaybes $ mapM (resolvePackageDatabase dflags) conf_refs-  mapM (readPackageDatabase dflags) confs---getPackageConfRefs :: DynFlags -> IO [PkgDbRef]-getPackageConfRefs dflags = do-  let system_conf_refs = [UserPkgDb, GlobalPkgDb]--  e_pkg_path <- tryIO (getEnv $ map toUpper (programName dflags) ++ "_PACKAGE_PATH")-  let base_conf_refs = case e_pkg_path of-        Left _ -> system_conf_refs-        Right path-         | not (null path) && isSearchPathSeparator (last path)-         -> map PkgDbPath (splitSearchPath (init path)) ++ system_conf_refs-         | otherwise-         -> map PkgDbPath (splitSearchPath path)--  -- Apply the package DB-related flags from the command line to get the-  -- final list of package DBs.-  ---  -- Notes on ordering:-  --  * The list of flags is reversed (later ones first)-  --  * We work with the package DB list in "left shadows right" order-  --  * and finally reverse it at the end, to get "right shadows left"-  ---  return $ reverse (foldr doFlag base_conf_refs (packageDBFlags dflags))- where-  doFlag (PackageDB p) dbs = p : dbs-  doFlag NoUserPackageDB dbs = filter isNotUser dbs-  doFlag NoGlobalPackageDB dbs = filter isNotGlobal dbs-  doFlag ClearPackageDBs _ = []--  isNotUser UserPkgDb = False-  isNotUser _ = True--  isNotGlobal GlobalPkgDb = False-  isNotGlobal _ = True---- | Return the path of a package database from a 'PkgDbRef'. Return 'Nothing'--- when the user database filepath is expected but the latter doesn't exist.------ NB: This logic is reimplemented in Cabal, so if you change it,--- make sure you update Cabal. (Or, better yet, dump it in the--- compiler info so Cabal can use the info.)-resolvePackageDatabase :: DynFlags -> PkgDbRef -> IO (Maybe FilePath)-resolvePackageDatabase dflags GlobalPkgDb = return $ Just (globalPackageDatabasePath dflags)-resolvePackageDatabase dflags UserPkgDb = runMaybeT $ do-  dir <- versionedAppDir dflags-  let pkgconf = dir </> "package.conf.d"-  exist <- tryMaybeT $ doesDirectoryExist pkgconf-  if exist then return pkgconf else mzero-resolvePackageDatabase _ (PkgDbPath name) = return $ Just name--readPackageDatabase :: DynFlags -> FilePath -> IO PackageDatabase-readPackageDatabase dflags conf_file = do-  isdir <- doesDirectoryExist conf_file--  proto_pkg_configs <--    if isdir-       then readDirStyleUnitInfo conf_file-       else do-            isfile <- doesFileExist conf_file-            if isfile-               then do-                 mpkgs <- tryReadOldFileStyleUnitInfo-                 case mpkgs of-                   Just pkgs -> return pkgs-                   Nothing   -> throwGhcExceptionIO $ InstallationError $-                      "ghc no longer supports single-file style package " ++-                      "databases (" ++ conf_file ++-                      ") use 'ghc-pkg init' to create the database with " ++-                      "the correct format."-               else throwGhcExceptionIO $ InstallationError $-                      "can't find a package database at " ++ conf_file--  let-      -- Fix #16360: remove trailing slash from conf_file before calculating pkgroot-      conf_file' = dropTrailingPathSeparator conf_file-      top_dir = topDir dflags-      pkgroot = takeDirectory conf_file'-      pkg_configs1 = map (mungeUnitInfo top_dir pkgroot)-                         proto_pkg_configs-  ---  return $ PackageDatabase conf_file' pkg_configs1-  where-    readDirStyleUnitInfo conf_dir = do-      let filename = conf_dir </> "package.cache"-      cache_exists <- doesFileExist filename-      if cache_exists-        then do-          debugTraceMsg dflags 2 $ text "Using binary package database:"-                                    <+> text filename-          readPackageDbForGhc filename-        else do-          -- If there is no package.cache file, we check if the database is not-          -- empty by inspecting if the directory contains any .conf file. If it-          -- does, something is wrong and we fail. Otherwise we assume that the-          -- database is empty.-          debugTraceMsg dflags 2 $ text "There is no package.cache in"-                               <+> text conf_dir-                                <> text ", checking if the database is empty"-          db_empty <- all (not . isSuffixOf ".conf")-                   <$> getDirectoryContents conf_dir-          if db_empty-            then do-              debugTraceMsg dflags 3 $ text "There are no .conf files in"-                                   <+> text conf_dir <> text ", treating"-                                   <+> text "package database as empty"-              return []-            else do-              throwGhcExceptionIO $ InstallationError $-                "there is no package.cache in " ++ conf_dir ++-                " even though package database is not empty"---    -- Single-file style package dbs have been deprecated for some time, but-    -- it turns out that Cabal was using them in one place. So this is a-    -- workaround to allow older Cabal versions to use this newer ghc.-    -- We check if the file db contains just "[]" and if so, we look for a new-    -- dir-style db in conf_file.d/, ie in a dir next to the given file.-    -- We cannot just replace the file with a new dir style since Cabal still-    -- assumes it's a file and tries to overwrite with 'writeFile'.-    -- ghc-pkg also cooperates with this workaround.-    tryReadOldFileStyleUnitInfo = do-      content <- readFile conf_file `catchIO` \_ -> return ""-      if take 2 content == "[]"-        then do-          let conf_dir = conf_file <.> "d"-          direxists <- doesDirectoryExist conf_dir-          if direxists-             then do debugTraceMsg dflags 2 (text "Ignoring old file-style db and trying:" <+> text conf_dir)-                     liftM Just (readDirStyleUnitInfo conf_dir)-             else return (Just []) -- ghc-pkg will create it when it's updated-        else return Nothing--distrustAllUnits :: [UnitInfo] -> [UnitInfo]-distrustAllUnits pkgs = map distrust pkgs-  where-    distrust pkg = pkg{ trusted = False }--mungeUnitInfo :: FilePath -> FilePath-                   -> UnitInfo -> UnitInfo-mungeUnitInfo top_dir pkgroot =-    mungeDynLibFields-  . mungePackagePaths top_dir pkgroot--mungeDynLibFields :: UnitInfo -> UnitInfo-mungeDynLibFields pkg =-    pkg {-      libraryDynDirs     = libraryDynDirs pkg-                `orIfNull` libraryDirs pkg-    }-  where-    orIfNull [] flags = flags-    orIfNull flags _  = flags---- TODO: This code is duplicated in utils/ghc-pkg/Main.hs-mungePackagePaths :: FilePath -> FilePath -> UnitInfo -> UnitInfo--- Perform path/URL variable substitution as per the Cabal ${pkgroot} spec--- (http://www.haskell.org/pipermail/libraries/2009-May/011772.html)--- Paths/URLs can be relative to ${pkgroot} or ${pkgrooturl}.--- The "pkgroot" is the directory containing the package database.------ Also perform a similar substitution for the older GHC-specific--- "$topdir" variable. The "topdir" is the location of the ghc--- installation (obtained from the -B option).-mungePackagePaths top_dir pkgroot pkg =-    pkg {-      importDirs  = munge_paths (importDirs pkg),-      includeDirs = munge_paths (includeDirs pkg),-      libraryDirs = munge_paths (libraryDirs pkg),-      libraryDynDirs = munge_paths (libraryDynDirs pkg),-      frameworkDirs = munge_paths (frameworkDirs pkg),-      haddockInterfaces = munge_paths (haddockInterfaces pkg),-      haddockHTMLs = munge_urls (haddockHTMLs pkg)-    }-  where-    munge_paths = map munge_path-    munge_urls  = map munge_url--    munge_path p-      | Just p' <- stripVarPrefix "${pkgroot}" p = pkgroot ++ p'-      | Just p' <- stripVarPrefix "$topdir"    p = top_dir ++ p'-      | otherwise                                = p--    munge_url p-      | Just p' <- stripVarPrefix "${pkgrooturl}" p = toUrlPath pkgroot p'-      | Just p' <- stripVarPrefix "$httptopdir"   p = toUrlPath top_dir p'-      | otherwise                                   = p--    toUrlPath r p = "file:///"-                 -- URLs always use posix style '/' separators:-                 ++ FilePath.Posix.joinPath-                        (r : -- We need to drop a leading "/" or "\\"-                             -- if there is one:-                             dropWhile (all isPathSeparator)-                                       (FilePath.splitDirectories p))--    -- We could drop the separator here, and then use </> above. However,-    -- by leaving it in and using ++ we keep the same path separator-    -- rather than letting FilePath change it to use \ as the separator-    stripVarPrefix var path = case stripPrefix var path of-                              Just [] -> Just []-                              Just cs@(c : _) | isPathSeparator c -> Just cs-                              _ -> Nothing----- -------------------------------------------------------------------------------- Modify our copy of the package database based on trust flags,--- -trust and -distrust.--applyTrustFlag-   :: DynFlags-   -> PackagePrecedenceIndex-   -> UnusablePackages-   -> [UnitInfo]-   -> TrustFlag-   -> IO [UnitInfo]-applyTrustFlag dflags prec_map unusable pkgs flag =-  case flag of-    -- we trust all matching packages. Maybe should only trust first one?-    -- and leave others the same or set them untrusted-    TrustPackage str ->-       case selectPackages prec_map (PackageArg str) pkgs unusable of-         Left ps       -> trustFlagErr dflags flag ps-         Right (ps,qs) -> return (map trust ps ++ qs)-          where trust p = p {trusted=True}--    DistrustPackage str ->-       case selectPackages prec_map (PackageArg str) pkgs unusable of-         Left ps       -> trustFlagErr dflags flag ps-         Right (ps,qs) -> return (distrustAllUnits ps ++ qs)---- | A little utility to tell if the 'thisPackage' is indefinite--- (if it is not, we should never use on-the-fly renaming.)-isIndefinite :: DynFlags -> Bool-isIndefinite dflags = not (unitIdIsDefinite (thisPackage dflags))--applyPackageFlag-   :: DynFlags-   -> PackagePrecedenceIndex-   -> UnitInfoMap-   -> UnusablePackages-   -> Bool -- if False, if you expose a package, it implicitly hides-           -- any previously exposed packages with the same name-   -> [UnitInfo]-   -> VisibilityMap           -- Initially exposed-   -> PackageFlag               -- flag to apply-   -> IO VisibilityMap        -- Now exposed--applyPackageFlag dflags prec_map pkg_db unusable no_hide_others pkgs vm flag =-  case flag of-    ExposePackage _ arg (ModRenaming b rns) ->-       case findPackages prec_map pkg_db arg pkgs unusable of-         Left ps         -> packageFlagErr dflags flag ps-         Right (p:_) -> return vm'-          where-           n = fsPackageName p--           -- If a user says @-unit-id p[A=<A>]@, this imposes-           -- a requirement on us: whatever our signature A is,-           -- it must fulfill all of p[A=<A>]:A's requirements.-           -- This method is responsible for computing what our-           -- inherited requirements are.-           reqs | UnitIdArg orig_uid <- arg = collectHoles orig_uid-                | otherwise                 = Map.empty--           collectHoles uid = case splitUnitIdInsts uid of-                (_, Just indef) ->-                  let local = [ Map.singleton-                                  (moduleName mod)-                                  (Set.singleton $ IndefModule indef mod_name)-                              | (mod_name, mod) <- indefUnitIdInsts indef-                              , isHoleModule mod ]-                      recurse = [ collectHoles (moduleUnitId mod)-                                | (_, mod) <- indefUnitIdInsts indef ]-                  in Map.unionsWith Set.union $ local ++ recurse-                -- Other types of unit identities don't have holes-                (_, Nothing) -> Map.empty---           uv = UnitVisibility-                { uv_expose_all = b-                , uv_renamings = rns-                , uv_package_name = First (Just n)-                , uv_requirements = reqs-                , uv_explicit = True-                }-           vm' = Map.insertWith mappend (packageConfigId p) uv vm_cleared-           -- In the old days, if you said `ghc -package p-0.1 -package p-0.2`-           -- (or if p-0.1 was registered in the pkgdb as exposed: True),-           -- the second package flag would override the first one and you-           -- would only see p-0.2 in exposed modules.  This is good for-           -- usability.-           ---           -- However, with thinning and renaming (or Backpack), there might be-           -- situations where you legitimately want to see two versions of a-           -- package at the same time, and this behavior would make it-           -- impossible to do so.  So we decided that if you pass-           -- -hide-all-packages, this should turn OFF the overriding behavior-           -- where an exposed package hides all other packages with the same-           -- name.  This should not affect Cabal at all, which only ever-           -- exposes one package at a time.-           ---           -- NB: Why a variable no_hide_others?  We have to apply this logic to-           -- -plugin-package too, and it's more consistent if the switch in-           -- behavior is based off of-           -- -hide-all-packages/-hide-all-plugin-packages depending on what-           -- flag is in question.-           vm_cleared | no_hide_others = vm-                      -- NB: renamings never clear-                      | (_:_) <- rns = vm-                      | otherwise = Map.filterWithKey-                            (\k uv -> k == packageConfigId p-                                   || First (Just n) /= uv_package_name uv) vm-         _ -> panic "applyPackageFlag"--    HidePackage str ->-       case findPackages prec_map pkg_db (PackageArg str) pkgs unusable of-         Left ps  -> packageFlagErr dflags flag ps-         Right ps -> return vm'-          where vm' = foldl' (flip Map.delete) vm (map packageConfigId ps)---- | Like 'selectPackages', but doesn't return a list of unmatched--- packages.  Furthermore, any packages it returns are *renamed*--- if the 'UnitArg' has a renaming associated with it.-findPackages :: PackagePrecedenceIndex-             -> UnitInfoMap -> PackageArg -> [UnitInfo]-             -> UnusablePackages-             -> Either [(UnitInfo, UnusablePackageReason)]-                [UnitInfo]-findPackages prec_map pkg_db arg pkgs unusable-  = let ps = mapMaybe (finder arg) pkgs-    in if null ps-        then Left (mapMaybe (\(x,y) -> finder arg x >>= \x' -> return (x',y))-                            (Map.elems unusable))-        else Right (sortByPreference prec_map ps)-  where-    finder (PackageArg str) p-      = if str == sourcePackageIdString p || str == packageNameString p-          then Just p-          else Nothing-    finder (UnitIdArg uid) p-      = let (iuid, mb_indef) = splitUnitIdInsts uid-        in if iuid == installedUnitInfoId p-              then Just (case mb_indef of-                            Nothing    -> p-                            Just indef -> renamePackage pkg_db (indefUnitIdInsts indef) p)-              else Nothing--selectPackages :: PackagePrecedenceIndex -> PackageArg -> [UnitInfo]-               -> UnusablePackages-               -> Either [(UnitInfo, UnusablePackageReason)]-                  ([UnitInfo], [UnitInfo])-selectPackages prec_map arg pkgs unusable-  = let matches = matching arg-        (ps,rest) = partition matches pkgs-    in if null ps-        then Left (filter (matches.fst) (Map.elems unusable))-        else Right (sortByPreference prec_map ps, rest)---- | Rename a 'UnitInfo' according to some module instantiation.-renamePackage :: UnitInfoMap -> [(ModuleName, Module)]-              -> UnitInfo -> UnitInfo-renamePackage pkg_map insts conf =-    let hsubst = listToUFM insts-        smod  = renameHoleModule' pkg_map hsubst-        new_insts = map (\(k,v) -> (k,smod v)) (instantiatedWith conf)-    in conf {-        instantiatedWith = new_insts,-        exposedModules = map (\(mod_name, mb_mod) -> (mod_name, fmap smod mb_mod))-                             (exposedModules conf)-    }----- A package named on the command line can either include the--- version, or just the name if it is unambiguous.-matchingStr :: String -> UnitInfo -> Bool-matchingStr str p-        =  str == sourcePackageIdString p-        || str == packageNameString p--matchingId :: InstalledUnitId -> UnitInfo -> Bool-matchingId uid p = uid == installedUnitInfoId p--matching :: PackageArg -> UnitInfo -> Bool-matching (PackageArg str) = matchingStr str-matching (UnitIdArg (DefiniteUnitId (DefUnitId uid)))  = matchingId uid-matching (UnitIdArg _)  = \_ -> False -- TODO: warn in this case---- | This sorts a list of packages, putting "preferred" packages first.--- See 'compareByPreference' for the semantics of "preference".-sortByPreference :: PackagePrecedenceIndex -> [UnitInfo] -> [UnitInfo]-sortByPreference prec_map = sortBy (flip (compareByPreference prec_map))---- | Returns 'GT' if @pkg@ should be preferred over @pkg'@ when picking--- which should be "active".  Here is the order of preference:------      1. First, prefer the latest version---      2. If the versions are the same, prefer the package that---      came in the latest package database.------ Pursuant to #12518, we could change this policy to, for example, remove--- the version preference, meaning that we would always prefer the packages--- in later package database.------ Instead, we use that preference based policy only when one of the packages--- is integer-gmp and the other is integer-simple.--- This currently only happens when we're looking up which concrete--- package to use in place of @integer-wired-in@ and that two different--- package databases supply a different integer library. For more about--- the fake @integer-wired-in@ package, see Note [The integer library]--- in the @PrelNames@ module.-compareByPreference-    :: PackagePrecedenceIndex-    -> UnitInfo-    -> UnitInfo-    -> Ordering-compareByPreference prec_map pkg pkg'-  | Just prec  <- Map.lookup (unitId pkg)  prec_map-  , Just prec' <- Map.lookup (unitId pkg') prec_map-  , differentIntegerPkgs pkg pkg'-  = compare prec prec'--  | otherwise-  = case comparing packageVersion pkg pkg' of-        GT -> GT-        EQ | Just prec  <- Map.lookup (unitId pkg)  prec_map-           , Just prec' <- Map.lookup (unitId pkg') prec_map-           -- Prefer the package from the later DB flag (i.e., higher-           -- precedence)-           -> compare prec prec'-           | otherwise-           -> EQ-        LT -> LT--  where isIntegerPkg p = packageNameString p `elem`-          ["integer-simple", "integer-gmp"]-        differentIntegerPkgs p p' =-          isIntegerPkg p && isIntegerPkg p' &&-          (packageName p /= packageName p')--comparing :: Ord a => (t -> a) -> t -> t -> Ordering-comparing f a b = f a `compare` f b--packageFlagErr :: DynFlags-               -> PackageFlag-               -> [(UnitInfo, UnusablePackageReason)]-               -> IO a-packageFlagErr dflags flag reasons-  = packageFlagErr' dflags (pprFlag flag) reasons--trustFlagErr :: DynFlags-             -> TrustFlag-             -> [(UnitInfo, UnusablePackageReason)]-             -> IO a-trustFlagErr dflags flag reasons-  = packageFlagErr' dflags (pprTrustFlag flag) reasons--packageFlagErr' :: DynFlags-               -> SDoc-               -> [(UnitInfo, UnusablePackageReason)]-               -> IO a-packageFlagErr' dflags flag_doc reasons-  = throwGhcExceptionIO (CmdLineError (showSDoc dflags $ err))-  where err = text "cannot satisfy " <> flag_doc <>-                (if null reasons then Outputable.empty else text ": ") $$-              nest 4 (ppr_reasons $$-                      text "(use -v for more information)")-        ppr_reasons = vcat (map ppr_reason reasons)-        ppr_reason (p, reason) =-            pprReason (ppr (unitId p) <+> text "is") reason--pprFlag :: PackageFlag -> SDoc-pprFlag flag = case flag of-    HidePackage p   -> text "-hide-package " <> text p-    ExposePackage doc _ _ -> text doc--pprTrustFlag :: TrustFlag -> SDoc-pprTrustFlag flag = case flag of-    TrustPackage p    -> text "-trust " <> text p-    DistrustPackage p -> text "-distrust " <> text p---- -------------------------------------------------------------------------------- Wired-in packages------ See Note [Wired-in packages] in Module--type WiredInUnitId = String-type WiredPackagesMap = Map WiredUnitId WiredUnitId--wired_in_unitids :: [WiredInUnitId]-wired_in_unitids = map unitIdString wiredInUnitIds--findWiredInPackages-   :: DynFlags-   -> PackagePrecedenceIndex-   -> [UnitInfo]           -- database-   -> VisibilityMap             -- info on what packages are visible-                                -- for wired in selection-   -> IO ([UnitInfo],  -- package database updated for wired in-          WiredPackagesMap) -- map from unit id to wired identity--findWiredInPackages dflags prec_map pkgs vis_map = do-  -- Now we must find our wired-in packages, and rename them to-  -- their canonical names (eg. base-1.0 ==> base), as described-  -- in Note [Wired-in packages] in Module-  let-        matches :: UnitInfo -> WiredInUnitId -> Bool-        pc `matches` pid-            -- See Note [The integer library] in PrelNames-            | pid == unitIdString integerUnitId-            = packageNameString pc `elem` ["integer-gmp", "integer-simple"]-        pc `matches` pid = packageNameString pc == pid--        -- find which package corresponds to each wired-in package-        -- delete any other packages with the same name-        -- update the package and any dependencies to point to the new-        -- one.-        ---        -- When choosing which package to map to a wired-in package-        -- name, we try to pick the latest version of exposed packages.-        -- However, if there are no exposed wired in packages available-        -- (e.g. -hide-all-packages was used), we can't bail: we *have*-        -- to assign a package for the wired-in package: so we try again-        -- with hidden packages included to (and pick the latest-        -- version).-        ---        -- You can also override the default choice by using -ignore-package:-        -- this works even when there is no exposed wired in package-        -- available.-        ---        findWiredInPackage :: [UnitInfo] -> WiredInUnitId-                           -> IO (Maybe (WiredInUnitId, UnitInfo))-        findWiredInPackage pkgs wired_pkg =-           let all_ps = [ p | p <- pkgs, p `matches` wired_pkg ]-               all_exposed_ps =-                    [ p | p <- all_ps-                        , Map.member (packageConfigId p) vis_map ] in-           case all_exposed_ps of-            [] -> case all_ps of-                       []   -> notfound-                       many -> pick (head (sortByPreference prec_map many))-            many -> pick (head (sortByPreference prec_map many))-          where-                notfound = do-                          debugTraceMsg dflags 2 $-                            text "wired-in package "-                                 <> text wired_pkg-                                 <> text " not found."-                          return Nothing-                pick :: UnitInfo-                     -> IO (Maybe (WiredInUnitId, UnitInfo))-                pick pkg = do-                        debugTraceMsg dflags 2 $-                            text "wired-in package "-                                 <> text wired_pkg-                                 <> text " mapped to "-                                 <> ppr (unitId pkg)-                        return (Just (wired_pkg, pkg))---  mb_wired_in_pkgs <- mapM (findWiredInPackage pkgs) wired_in_unitids-  let-        wired_in_pkgs = catMaybes mb_wired_in_pkgs--        -- this is old: we used to assume that if there were-        -- multiple versions of wired-in packages installed that-        -- they were mutually exclusive.  Now we're assuming that-        -- you have one "main" version of each wired-in package-        -- (the latest version), and the others are backward-compat-        -- wrappers that depend on this one.  e.g. base-4.0 is the-        -- latest, base-3.0 is a compat wrapper depending on base-4.0.-        {--        deleteOtherWiredInPackages pkgs = filterOut bad pkgs-          where bad p = any (p `matches`) wired_in_unitids-                      && package p `notElem` map fst wired_in_ids-        -}--        wiredInMap :: Map WiredUnitId WiredUnitId-        wiredInMap = Map.fromList-          [ (key, DefUnitId (stringToInstalledUnitId wiredInUnitId))-          | (wiredInUnitId, pkg) <- wired_in_pkgs-          , Just key <- pure $ definiteUnitInfoId pkg-          ]--        updateWiredInDependencies pkgs = map (upd_deps . upd_pkg) pkgs-          where upd_pkg pkg-                  | Just def_uid <- definiteUnitInfoId pkg-                  , Just wiredInUnitId <- Map.lookup def_uid wiredInMap-                  = let fs = installedUnitIdFS (unDefUnitId wiredInUnitId)-                    in pkg {-                      unitId = fsToInstalledUnitId fs,-                      componentId = ComponentId fs-                    }-                  | otherwise-                  = pkg-                upd_deps pkg = pkg {-                      -- temporary harmless DefUnitId invariant violation-                      depends = map (unDefUnitId . upd_wired_in wiredInMap . DefUnitId) (depends pkg),-                      exposedModules-                        = map (\(k,v) -> (k, fmap (upd_wired_in_mod wiredInMap) v))-                              (exposedModules pkg)-                    }---  return (updateWiredInDependencies pkgs, wiredInMap)---- Helper functions for rewiring Module and UnitId.  These--- rewrite UnitIds of modules in wired-in packages to the form known to the--- compiler, as described in Note [Wired-in packages] in Module.------ For instance, base-4.9.0.0 will be rewritten to just base, to match--- what appears in PrelNames.--upd_wired_in_mod :: WiredPackagesMap -> Module -> Module-upd_wired_in_mod wiredInMap (Module uid m) = Module (upd_wired_in_uid wiredInMap uid) m--upd_wired_in_uid :: WiredPackagesMap -> UnitId -> UnitId-upd_wired_in_uid wiredInMap (DefiniteUnitId def_uid) =-    DefiniteUnitId (upd_wired_in wiredInMap def_uid)-upd_wired_in_uid wiredInMap (IndefiniteUnitId indef_uid) =-    IndefiniteUnitId $ newIndefUnitId-        (indefUnitIdComponentId indef_uid)-        (map (\(x,y) -> (x,upd_wired_in_mod wiredInMap y)) (indefUnitIdInsts indef_uid))--upd_wired_in :: WiredPackagesMap -> DefUnitId -> DefUnitId-upd_wired_in wiredInMap key-    | Just key' <- Map.lookup key wiredInMap = key'-    | otherwise = key--updateVisibilityMap :: WiredPackagesMap -> VisibilityMap -> VisibilityMap-updateVisibilityMap wiredInMap vis_map = foldl' f vis_map (Map.toList wiredInMap)-  where f vm (from, to) = case Map.lookup (DefiniteUnitId from) vis_map of-                    Nothing -> vm-                    Just r -> Map.insert (DefiniteUnitId to) r-                                (Map.delete (DefiniteUnitId from) vm)----- -------------------------------------------------------------------------------- | The reason why a package is unusable.-data UnusablePackageReason-  = -- | We ignored it explicitly using @-ignore-package@.-    IgnoredWithFlag-    -- | This package transitively depends on a package that was never present-    -- in any of the provided databases.-  | BrokenDependencies   [InstalledUnitId]-    -- | This package transitively depends on a package involved in a cycle.-    -- Note that the list of 'InstalledUnitId' reports the direct dependencies-    -- of this package that (transitively) depended on the cycle, and not-    -- the actual cycle itself (which we report separately at high verbosity.)-  | CyclicDependencies   [InstalledUnitId]-    -- | This package transitively depends on a package which was ignored.-  | IgnoredDependencies  [InstalledUnitId]-    -- | This package transitively depends on a package which was-    -- shadowed by an ABI-incompatible package.-  | ShadowedDependencies [InstalledUnitId]--instance Outputable UnusablePackageReason where-    ppr IgnoredWithFlag = text "[ignored with flag]"-    ppr (BrokenDependencies uids)   = brackets (text "broken" <+> ppr uids)-    ppr (CyclicDependencies uids)   = brackets (text "cyclic" <+> ppr uids)-    ppr (IgnoredDependencies uids)  = brackets (text "ignored" <+> ppr uids)-    ppr (ShadowedDependencies uids) = brackets (text "shadowed" <+> ppr uids)--type UnusablePackages = Map InstalledUnitId-                            (UnitInfo, UnusablePackageReason)--pprReason :: SDoc -> UnusablePackageReason -> SDoc-pprReason pref reason = case reason of-  IgnoredWithFlag ->-      pref <+> text "ignored due to an -ignore-package flag"-  BrokenDependencies deps ->-      pref <+> text "unusable due to missing dependencies:" $$-        nest 2 (hsep (map ppr deps))-  CyclicDependencies deps ->-      pref <+> text "unusable due to cyclic dependencies:" $$-        nest 2 (hsep (map ppr deps))-  IgnoredDependencies deps ->-      pref <+> text ("unusable because the -ignore-package flag was used to " ++-                     "ignore at least one of its dependencies:") $$-        nest 2 (hsep (map ppr deps))-  ShadowedDependencies deps ->-      pref <+> text "unusable due to shadowed dependencies:" $$-        nest 2 (hsep (map ppr deps))--reportCycles :: DynFlags -> [SCC UnitInfo] -> IO ()-reportCycles dflags sccs = mapM_ report sccs-  where-    report (AcyclicSCC _) = return ()-    report (CyclicSCC vs) =-        debugTraceMsg dflags 2 $-          text "these packages are involved in a cycle:" $$-            nest 2 (hsep (map (ppr . unitId) vs))--reportUnusable :: DynFlags -> UnusablePackages -> IO ()-reportUnusable dflags pkgs = mapM_ report (Map.toList pkgs)-  where-    report (ipid, (_, reason)) =-       debugTraceMsg dflags 2 $-         pprReason-           (text "package" <+> ppr ipid <+> text "is") reason---- ---------------------------------------------------------------------------------- Utilities on the database------- | A reverse dependency index, mapping an 'InstalledUnitId' to--- the 'InstalledUnitId's which have a dependency on it.-type RevIndex = Map InstalledUnitId [InstalledUnitId]---- | Compute the reverse dependency index of a package database.-reverseDeps :: InstalledPackageIndex -> RevIndex-reverseDeps db = Map.foldl' go Map.empty db-  where-    go r pkg = foldl' (go' (unitId pkg)) r (depends pkg)-    go' from r to = Map.insertWith (++) to [from] r---- | Given a list of 'InstalledUnitId's to remove, a database,--- and a reverse dependency index (as computed by 'reverseDeps'),--- remove those packages, plus any packages which depend on them.--- Returns the pruned database, as well as a list of 'UnitInfo's--- that was removed.-removePackages :: [InstalledUnitId] -> RevIndex-               -> InstalledPackageIndex-               -> (InstalledPackageIndex, [UnitInfo])-removePackages uids index m = go uids (m,[])-  where-    go [] (m,pkgs) = (m,pkgs)-    go (uid:uids) (m,pkgs)-        | Just pkg <- Map.lookup uid m-        = case Map.lookup uid index of-            Nothing    -> go uids (Map.delete uid m, pkg:pkgs)-            Just rdeps -> go (rdeps ++ uids) (Map.delete uid m, pkg:pkgs)-        | otherwise-        = go uids (m,pkgs)---- | Given a 'UnitInfo' from some 'InstalledPackageIndex',--- return all entries in 'depends' which correspond to packages--- that do not exist in the index.-depsNotAvailable :: InstalledPackageIndex-                 -> UnitInfo-                 -> [InstalledUnitId]-depsNotAvailable pkg_map pkg = filter (not . (`Map.member` pkg_map)) (depends pkg)---- | Given a 'UnitInfo' from some 'InstalledPackageIndex'--- return all entries in 'abiDepends' which correspond to packages--- that do not exist, OR have mismatching ABIs.-depsAbiMismatch :: InstalledPackageIndex-                -> UnitInfo-                -> [InstalledUnitId]-depsAbiMismatch pkg_map pkg = map fst . filter (not . abiMatch) $ abiDepends pkg-  where-    abiMatch (dep_uid, abi)-        | Just dep_pkg <- Map.lookup dep_uid pkg_map-        = abiHash dep_pkg == abi-        | otherwise-        = False---- -------------------------------------------------------------------------------- Ignore packages--ignorePackages :: [IgnorePackageFlag] -> [UnitInfo] -> UnusablePackages-ignorePackages flags pkgs = Map.fromList (concatMap doit flags)-  where-  doit (IgnorePackage str) =-     case partition (matchingStr str) pkgs of-         (ps, _) -> [ (unitId p, (p, IgnoredWithFlag))-                    | p <- ps ]-        -- missing package is not an error for -ignore-package,-        -- because a common usage is to -ignore-package P as-        -- a preventative measure just in case P exists.---- ---------------------------------------------------------------------------------- Merging databases------- | For each package, a mapping from uid -> i indicates that this--- package was brought into GHC by the ith @-package-db@ flag on--- the command line.  We use this mapping to make sure we prefer--- packages that were defined later on the command line, if there--- is an ambiguity.-type PackagePrecedenceIndex = Map InstalledUnitId Int---- | Given a list of databases, merge them together, where--- packages with the same unit id in later databases override--- earlier ones.  This does NOT check if the resulting database--- makes sense (that's done by 'validateDatabase').-mergeDatabases :: DynFlags -> [PackageDatabase]-               -> IO (InstalledPackageIndex, PackagePrecedenceIndex)-mergeDatabases dflags = foldM merge (Map.empty, Map.empty) . zip [1..]-  where-    merge (pkg_map, prec_map) (i, PackageDatabase db_path db) = do-      debugTraceMsg dflags 2 $-          text "loading package database" <+> text db_path-      forM_ (Set.toList override_set) $ \pkg ->-          debugTraceMsg dflags 2 $-              text "package" <+> ppr pkg <+>-              text "overrides a previously defined package"-      return (pkg_map', prec_map')-     where-      db_map = mk_pkg_map db-      mk_pkg_map = Map.fromList . map (\p -> (unitId p, p))--      -- The set of UnitIds which appear in both db and pkgs.  These are the-      -- ones that get overridden.  Compute this just to give some-      -- helpful debug messages at -v2-      override_set :: Set InstalledUnitId-      override_set = Set.intersection (Map.keysSet db_map)-                                      (Map.keysSet pkg_map)--      -- Now merge the sets together (NB: in case of duplicate,-      -- first argument preferred)-      pkg_map' :: InstalledPackageIndex-      pkg_map' = Map.union db_map pkg_map--      prec_map' :: PackagePrecedenceIndex-      prec_map' = Map.union (Map.map (const i) db_map) prec_map---- | Validates a database, removing unusable packages from it--- (this includes removing packages that the user has explicitly--- ignored.)  Our general strategy:------ 1. Remove all broken packages (dangling dependencies)--- 2. Remove all packages that are cyclic--- 3. Apply ignore flags--- 4. Remove all packages which have deps with mismatching ABIs----validateDatabase :: DynFlags -> InstalledPackageIndex-                 -> (InstalledPackageIndex, UnusablePackages, [SCC UnitInfo])-validateDatabase dflags pkg_map1 =-    (pkg_map5, unusable, sccs)-  where-    ignore_flags = reverse (ignorePackageFlags dflags)--    -- Compute the reverse dependency index-    index = reverseDeps pkg_map1--    -- Helper function-    mk_unusable mk_err dep_matcher m uids =-      Map.fromList [ (unitId pkg, (pkg, mk_err (dep_matcher m pkg)))-                   | pkg <- uids ]--    -- Find broken packages-    directly_broken = filter (not . null . depsNotAvailable pkg_map1)-                             (Map.elems pkg_map1)-    (pkg_map2, broken) = removePackages (map unitId directly_broken) index pkg_map1-    unusable_broken = mk_unusable BrokenDependencies depsNotAvailable pkg_map2 broken--    -- Find recursive packages-    sccs = stronglyConnComp [ (pkg, unitId pkg, depends pkg)-                            | pkg <- Map.elems pkg_map2 ]-    getCyclicSCC (CyclicSCC vs) = map unitId vs-    getCyclicSCC (AcyclicSCC _) = []-    (pkg_map3, cyclic) = removePackages (concatMap getCyclicSCC sccs) index pkg_map2-    unusable_cyclic = mk_unusable CyclicDependencies depsNotAvailable pkg_map3 cyclic--    -- Apply ignore flags-    directly_ignored = ignorePackages ignore_flags (Map.elems pkg_map3)-    (pkg_map4, ignored) = removePackages (Map.keys directly_ignored) index pkg_map3-    unusable_ignored = mk_unusable IgnoredDependencies depsNotAvailable pkg_map4 ignored--    -- Knock out packages whose dependencies don't agree with ABI-    -- (i.e., got invalidated due to shadowing)-    directly_shadowed = filter (not . null . depsAbiMismatch pkg_map4)-                               (Map.elems pkg_map4)-    (pkg_map5, shadowed) = removePackages (map unitId directly_shadowed) index pkg_map4-    unusable_shadowed = mk_unusable ShadowedDependencies depsAbiMismatch pkg_map5 shadowed--    unusable = directly_ignored `Map.union` unusable_ignored-                                `Map.union` unusable_broken-                                `Map.union` unusable_cyclic-                                `Map.union` unusable_shadowed---- -------------------------------------------------------------------------------- When all the command-line options are in, we can process our package--- settings and populate the package state.--mkPackageState-    :: DynFlags-    -- initial databases, in the order they were specified on-    -- the command line (later databases shadow earlier ones)-    -> [PackageDatabase]-    -> [PreloadUnitId]              -- preloaded packages-    -> IO (PackageState,-           [PreloadUnitId],         -- new packages to preload-           Maybe [(ModuleName, Module)])--mkPackageState dflags dbs preload0 = do-{--   Plan.--   There are two main steps for making the package state:--    1. We want to build a single, unified package database based-       on all of the input databases, which upholds the invariant that-       there is only one package per any UnitId and there are no-       dangling dependencies.  We'll do this by merging, and-       then successively filtering out bad dependencies.--       a) Merge all the databases together.-          If an input database defines unit ID that is already in-          the unified database, that package SHADOWS the existing-          package in the current unified database.  Note that-          order is important: packages defined later in the list of-          command line arguments shadow those defined earlier.--       b) Remove all packages with missing dependencies, or-          mutually recursive dependencies.--       b) Remove packages selected by -ignore-package from input database--       c) Remove all packages which depended on packages that are now-          shadowed by an ABI-incompatible package--       d) report (with -v) any packages that were removed by steps 1-3--    2. We want to look at the flags controlling package visibility,-       and build a mapping of what module names are in scope and-       where they live.--       a) on the final, unified database, we apply -trust/-distrust-          flags directly, modifying the database so that the 'trusted'-          field has the correct value.--       b) we use the -package/-hide-package flags to compute a-          visibility map, stating what packages are "exposed" for-          the purposes of computing the module map.-          * if any flag refers to a package which was removed by 1-5, then-            we can give an error message explaining why-          * if -hide-all-packages was not specified, this step also-            hides packages which are superseded by later exposed packages-          * this step is done TWICE if -plugin-package/-hide-all-plugin-packages-            are used--       c) based on the visibility map, we pick wired packages and rewrite-          them to have the expected unitId.--       d) finally, using the visibility map and the package database,-          we build a mapping saying what every in scope module name points to.--}--  -- This, and the other reverse's that you will see, are due to the fact that-  -- packageFlags, pluginPackageFlags, etc. are all specified in *reverse* order-  -- than they are on the command line.-  let other_flags = reverse (packageFlags dflags)-  debugTraceMsg dflags 2 $-      text "package flags" <+> ppr other_flags--  -- Merge databases together, without checking validity-  (pkg_map1, prec_map) <- mergeDatabases dflags dbs--  -- Now that we've merged everything together, prune out unusable-  -- packages.-  let (pkg_map2, unusable, sccs) = validateDatabase dflags pkg_map1--  reportCycles dflags sccs-  reportUnusable dflags unusable--  -- Apply trust flags (these flags apply regardless of whether-  -- or not packages are visible or not)-  pkgs1 <- foldM (applyTrustFlag dflags prec_map unusable)-                 (Map.elems pkg_map2) (reverse (trustFlags dflags))-  let prelim_pkg_db = extendUnitInfoMap emptyUnitInfoMap pkgs1--  ---  -- Calculate the initial set of units from package databases, prior to any package flags.-  ---  -- Conceptually, we select the latest versions of all valid (not unusable) *packages*-  -- (not units). This is empty if we have -hide-all-packages.-  ---  -- Then we create an initial visibility map with default visibilities for all-  -- exposed, definite units which belong to the latest valid packages.-  ---  let preferLater unit unit' =-        case compareByPreference prec_map unit unit' of-            GT -> unit-            _  -> unit'-      addIfMorePreferable m unit = addToUDFM_C preferLater m (fsPackageName unit) unit-      -- This is the set of maximally preferable packages. In fact, it is a set of-      -- most preferable *units* keyed by package name, which act as stand-ins in-      -- for "a package in a database". We use units here because we don't have-      -- "a package in a database" as a type currently.-      mostPreferablePackageReps = if gopt Opt_HideAllPackages dflags-                    then emptyUDFM-                    else foldl' addIfMorePreferable emptyUDFM pkgs1-      -- When exposing units, we want to consider all of those in the most preferable-      -- packages. We can implement that by looking for units that are equi-preferable-      -- with the most preferable unit for package. Being equi-preferable means that-      -- they must be in the same database, with the same version, and the same package name.-      ---      -- We must take care to consider all these units and not just the most-      -- preferable one, otherwise we can end up with problems like #16228.-      mostPreferable u =-        case lookupUDFM mostPreferablePackageReps (fsPackageName u) of-          Nothing -> False-          Just u' -> compareByPreference prec_map u u' == EQ-      vis_map1 = foldl' (\vm p ->-                            -- Note: we NEVER expose indefinite packages by-                            -- default, because it's almost assuredly not-                            -- what you want (no mix-in linking has occurred).-                            if exposed p && unitIdIsDefinite (packageConfigId p) && mostPreferable p-                               then Map.insert (packageConfigId p)-                                               UnitVisibility {-                                                 uv_expose_all = True,-                                                 uv_renamings = [],-                                                 uv_package_name = First (Just (fsPackageName p)),-                                                 uv_requirements = Map.empty,-                                                 uv_explicit = False-                                               }-                                               vm-                               else vm)-                         Map.empty pkgs1--  ---  -- Compute a visibility map according to the command-line flags (-package,-  -- -hide-package).  This needs to know about the unusable packages, since if a-  -- user tries to enable an unusable package, we should let them know.-  ---  vis_map2 <- foldM (applyPackageFlag dflags prec_map prelim_pkg_db unusable-                        (gopt Opt_HideAllPackages dflags) pkgs1)-                            vis_map1 other_flags--  ---  -- Sort out which packages are wired in. This has to be done last, since-  -- it modifies the unit ids of wired in packages, but when we process-  -- package arguments we need to key against the old versions.-  ---  (pkgs2, wired_map) <- findWiredInPackages dflags prec_map pkgs1 vis_map2-  let pkg_db = extendUnitInfoMap emptyUnitInfoMap pkgs2--  -- Update the visibility map, so we treat wired packages as visible.-  let vis_map = updateVisibilityMap wired_map vis_map2--  let hide_plugin_pkgs = gopt Opt_HideAllPluginPackages dflags-  plugin_vis_map <--    case pluginPackageFlags dflags of-        -- common case; try to share the old vis_map-        [] | not hide_plugin_pkgs -> return vis_map-           | otherwise -> return Map.empty-        _ -> do let plugin_vis_map1-                        | hide_plugin_pkgs = Map.empty-                        -- Use the vis_map PRIOR to wired in,-                        -- because otherwise applyPackageFlag-                        -- won't work.-                        | otherwise = vis_map2-                plugin_vis_map2-                    <- foldM (applyPackageFlag dflags prec_map prelim_pkg_db unusable-                                (gopt Opt_HideAllPluginPackages dflags) pkgs1)-                             plugin_vis_map1-                             (reverse (pluginPackageFlags dflags))-                -- Updating based on wired in packages is mostly-                -- good hygiene, because it won't matter: no wired in-                -- package has a compiler plugin.-                -- TODO: If a wired in package had a compiler plugin,-                -- and you tried to pick different wired in packages-                -- with the plugin flags and the normal flags... what-                -- would happen?  I don't know!  But this doesn't seem-                -- likely to actually happen.-                return (updateVisibilityMap wired_map plugin_vis_map2)--  ---  -- Here we build up a set of the packages mentioned in -package-  -- flags on the command line; these are called the "preload"-  -- packages.  we link these packages in eagerly.  The preload set-  -- should contain at least rts & base, which is why we pretend that-  -- the command line contains -package rts & -package base.-  ---  -- NB: preload IS important even for type-checking, because we-  -- need the correct include path to be set.-  ---  let preload1 = Map.keys (Map.filter uv_explicit vis_map)--  let pkgname_map = foldl' add Map.empty pkgs2-        where add pn_map p-                = Map.insert (packageName p) (componentId p) pn_map--  -- The explicitPackages accurately reflects the set of packages we have turned-  -- on; as such, it also is the only way one can come up with requirements.-  -- The requirement context is directly based off of this: we simply-  -- look for nested unit IDs that are directly fed holes: the requirements-  -- of those units are precisely the ones we need to track-  let explicit_pkgs = Map.keys vis_map-      req_ctx = Map.map (Set.toList)-              $ Map.unionsWith Set.union (map uv_requirements (Map.elems vis_map))---  let preload2 = preload1--  let-      -- add base & rts to the preload packages-      basicLinkedPackages-       | gopt Opt_AutoLinkPackages dflags-          = filter (flip elemUDFM (unUnitInfoMap pkg_db))-                [baseUnitId, rtsUnitId]-       | otherwise = []-      -- but in any case remove the current package from the set of-      -- preloaded packages so that base/rts does not end up in the-      -- set up preloaded package when we are just building it-      -- (NB: since this is only relevant for base/rts it doesn't matter-      -- that thisUnitIdInsts_ is not wired yet)-      ---      preload3 = ordNub $ filter (/= thisPackage dflags)-                        $ (basicLinkedPackages ++ preload2)--  -- Close the preload packages with their dependencies-  dep_preload <- closeDeps dflags pkg_db (zip (map toInstalledUnitId preload3) (repeat Nothing))-  let new_dep_preload = filter (`notElem` preload0) dep_preload--  let mod_map1 = mkModuleNameProvidersMap dflags pkg_db vis_map-      mod_map2 = mkUnusableModuleNameProvidersMap unusable-      mod_map = Map.union mod_map1 mod_map2--  dumpIfSet_dyn (dflags { pprCols = 200 }) Opt_D_dump_mod_map "Mod Map"-    FormatText-    (pprModuleMap mod_map)--  -- Force pstate to avoid leaking the dflags0 passed to mkPackageState-  let !pstate = PackageState{-    preloadPackages     = dep_preload,-    explicitPackages    = explicit_pkgs,-    unitInfoMap            = pkg_db,-    moduleNameProvidersMap  = mod_map,-    pluginModuleNameProvidersMap = mkModuleNameProvidersMap dflags pkg_db plugin_vis_map,-    packageNameMap          = pkgname_map,-    unwireMap = Map.fromList [ (v,k) | (k,v) <- Map.toList wired_map ],-    requirementContext = req_ctx-    }-  let new_insts = fmap (map (fmap (upd_wired_in_mod wired_map))) (thisUnitIdInsts_ dflags)-  return (pstate, new_dep_preload, new_insts)---- | Given a wired-in 'UnitId', "unwire" it into the 'UnitId'--- that it was recorded as in the package database.-unwireUnitId :: DynFlags -> UnitId -> UnitId-unwireUnitId dflags uid@(DefiniteUnitId def_uid) =-    maybe uid DefiniteUnitId (Map.lookup def_uid (unwireMap (pkgState dflags)))-unwireUnitId _ uid = uid---- -------------------------------------------------------------------------------- | Makes the mapping from module to package info---- Slight irritation: we proceed by leafing through everything--- in the installed package database, which makes handling indefinite--- packages a bit bothersome.--mkModuleNameProvidersMap-  :: DynFlags-  -> UnitInfoMap-  -> VisibilityMap-  -> ModuleNameProvidersMap-mkModuleNameProvidersMap dflags pkg_db vis_map =-    -- What should we fold on?  Both situations are awkward:-    ---    --    * Folding on the visibility map means that we won't create-    --      entries for packages that aren't mentioned in vis_map-    --      (e.g., hidden packages, causing #14717)-    ---    --    * Folding on pkg_db is awkward because if we have an-    --      Backpack instantiation, we need to possibly add a-    --      package from pkg_db multiple times to the actual-    --      ModuleNameProvidersMap.  Also, we don't really want-    --      definite package instantiations to show up in the-    --      list of possibilities.-    ---    -- So what will we do instead?  We'll extend vis_map with-    -- entries for every definite (for non-Backpack) and-    -- indefinite (for Backpack) package, so that we get the-    -- hidden entries we need.-    Map.foldlWithKey extend_modmap emptyMap vis_map_extended- where-  vis_map_extended = Map.union vis_map {- preferred -} default_vis--  default_vis = Map.fromList-                  [ (packageConfigId pkg, mempty)-                  | pkg <- eltsUDFM (unUnitInfoMap pkg_db)-                  -- Exclude specific instantiations of an indefinite-                  -- package-                  , indefinite pkg || null (instantiatedWith pkg)-                  ]--  emptyMap = Map.empty-  setOrigins m os = fmap (const os) m-  extend_modmap modmap uid-    UnitVisibility { uv_expose_all = b, uv_renamings = rns }-    = addListTo modmap theBindings-   where-    pkg = unit_lookup uid--    theBindings :: [(ModuleName, Map Module ModuleOrigin)]-    theBindings = newBindings b rns--    newBindings :: Bool-                -> [(ModuleName, ModuleName)]-                -> [(ModuleName, Map Module ModuleOrigin)]-    newBindings e rns  = es e ++ hiddens ++ map rnBinding rns--    rnBinding :: (ModuleName, ModuleName)-              -> (ModuleName, Map Module ModuleOrigin)-    rnBinding (orig, new) = (new, setOrigins origEntry fromFlag)-     where origEntry = case lookupUFM esmap orig of-            Just r -> r-            Nothing -> throwGhcException (CmdLineError (showSDoc dflags-                        (text "package flag: could not find module name" <+>-                            ppr orig <+> text "in package" <+> ppr pk)))--    es :: Bool -> [(ModuleName, Map Module ModuleOrigin)]-    es e = do-     (m, exposedReexport) <- exposed_mods-     let (pk', m', origin') =-          case exposedReexport of-           Nothing -> (pk, m, fromExposedModules e)-           Just (Module pk' m') ->-            let pkg' = unit_lookup pk'-            in (pk', m', fromReexportedModules e pkg')-     return (m, mkModMap pk' m' origin')--    esmap :: UniqFM (Map Module ModuleOrigin)-    esmap = listToUFM (es False) -- parameter here doesn't matter, orig will-                                 -- be overwritten--    hiddens = [(m, mkModMap pk m ModHidden) | m <- hidden_mods]--    pk = packageConfigId pkg-    unit_lookup uid = lookupUnit' (isIndefinite dflags) pkg_db uid-                        `orElse` pprPanic "unit_lookup" (ppr uid)--    exposed_mods = exposedModules pkg-    hidden_mods = hiddenModules pkg---- | Make a 'ModuleNameProvidersMap' covering a set of unusable packages.-mkUnusableModuleNameProvidersMap :: UnusablePackages -> ModuleNameProvidersMap-mkUnusableModuleNameProvidersMap unusables =-    Map.foldl' extend_modmap Map.empty unusables- where-    extend_modmap modmap (pkg, reason) = addListTo modmap bindings-      where bindings :: [(ModuleName, Map Module ModuleOrigin)]-            bindings = exposed ++ hidden--            origin = ModUnusable reason-            pkg_id = packageConfigId pkg--            exposed = map get_exposed exposed_mods-            hidden = [(m, mkModMap pkg_id m origin) | m <- hidden_mods]--            get_exposed (mod, Just mod') = (mod, Map.singleton mod' origin)-            get_exposed (mod, _)         = (mod, mkModMap pkg_id mod origin)--            exposed_mods = exposedModules pkg-            hidden_mods = hiddenModules pkg---- | Add a list of key/value pairs to a nested map.------ The outer map is processed with 'Data.Map.Strict' to prevent memory leaks--- when reloading modules in GHCi (see #4029). This ensures that each--- value is forced before installing into the map.-addListTo :: (Monoid a, Ord k1, Ord k2)-          => Map k1 (Map k2 a)-          -> [(k1, Map k2 a)]-          -> Map k1 (Map k2 a)-addListTo = foldl' merge-  where merge m (k, v) = MapStrict.insertWith (Map.unionWith mappend) k v m---- | Create a singleton module mapping-mkModMap :: UnitId -> ModuleName -> ModuleOrigin -> Map Module ModuleOrigin-mkModMap pkg mod = Map.singleton (mkModule pkg mod)---- -------------------------------------------------------------------------------- Extracting information from the packages in scope---- Many of these functions take a list of packages: in those cases,--- the list is expected to contain the "dependent packages",--- i.e. those packages that were found to be depended on by the--- current module/program.  These can be auto or non-auto packages, it--- doesn't really matter.  The list is always combined with the list--- of preload (command-line) packages to determine which packages to--- use.---- | Find all the include directories in these and the preload packages-getPackageIncludePath :: DynFlags -> [PreloadUnitId] -> IO [String]-getPackageIncludePath dflags pkgs =-  collectIncludeDirs `fmap` getPreloadPackagesAnd dflags pkgs--collectIncludeDirs :: [UnitInfo] -> [FilePath]-collectIncludeDirs ps = ordNub (filter notNull (concatMap includeDirs ps))---- | Find all the library paths in these and the preload packages-getPackageLibraryPath :: DynFlags -> [PreloadUnitId] -> IO [String]-getPackageLibraryPath dflags pkgs =-  collectLibraryPaths dflags `fmap` getPreloadPackagesAnd dflags pkgs--collectLibraryPaths :: DynFlags -> [UnitInfo] -> [FilePath]-collectLibraryPaths dflags = ordNub . filter notNull-                           . concatMap (libraryDirsForWay dflags)---- | Find all the link options in these and the preload packages,--- returning (package hs lib options, extra library options, other flags)-getPackageLinkOpts :: DynFlags -> [PreloadUnitId] -> IO ([String], [String], [String])-getPackageLinkOpts dflags pkgs =-  collectLinkOpts dflags `fmap` getPreloadPackagesAnd dflags pkgs--collectLinkOpts :: DynFlags -> [UnitInfo] -> ([String], [String], [String])-collectLinkOpts dflags ps =-    (-        concatMap (map ("-l" ++) . packageHsLibs dflags) ps,-        concatMap (map ("-l" ++) . extraLibraries) ps,-        concatMap ldOptions ps-    )-collectArchives :: DynFlags -> UnitInfo -> IO [FilePath]-collectArchives dflags pc =-  filterM doesFileExist [ searchPath </> ("lib" ++ lib ++ ".a")-                        | searchPath <- searchPaths-                        , lib <- libs ]-  where searchPaths = ordNub . filter notNull . libraryDirsForWay dflags $ pc-        libs        = packageHsLibs dflags pc ++ extraLibraries pc--getLibs :: DynFlags -> [PreloadUnitId] -> IO [(String,String)]-getLibs dflags pkgs = do-  ps <- getPreloadPackagesAnd dflags pkgs-  fmap concat . forM ps $ \p -> do-    let candidates = [ (l </> f, f) | l <- collectLibraryPaths dflags [p]-                                    , f <- (\n -> "lib" ++ n ++ ".a") <$> packageHsLibs dflags p ]-    filterM (doesFileExist . fst) candidates--packageHsLibs :: DynFlags -> UnitInfo -> [String]-packageHsLibs dflags p = map (mkDynName . addSuffix) (hsLibraries p)-  where-        ways0 = ways dflags--        ways1 = filter (/= WayDyn) ways0-        -- the name of a shared library is libHSfoo-ghc<version>.so-        -- we leave out the _dyn, because it is superfluous--        -- debug and profiled RTSs include support for -eventlog-        ways2 | WayDebug `elem` ways1 || WayProf `elem` ways1-              = filter (/= WayEventLog) ways1-              | otherwise-              = ways1--        tag     = mkBuildTag (filter (not . wayRTSOnly) ways2)-        rts_tag = mkBuildTag ways2--        mkDynName x-         | WayDyn `notElem` ways dflags = x-         | "HS" `isPrefixOf` x          =-              x ++ '-':programName dflags ++ projectVersion dflags-           -- For non-Haskell libraries, we use the name "Cfoo". The .a-           -- file is libCfoo.a, and the .so is libfoo.so. That way the-           -- linker knows what we mean for the vanilla (-lCfoo) and dyn-           -- (-lfoo) ways. We therefore need to strip the 'C' off here.-         | Just x' <- stripPrefix "C" x = x'-         | 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 = ""-                    | otherwise = '_':t---- | Either the 'libraryDirs' or 'libraryDynDirs' as appropriate for the way.-libraryDirsForWay :: DynFlags -> UnitInfo -> [String]-libraryDirsForWay dflags-  | WayDyn `elem` ways dflags = libraryDynDirs-  | otherwise                 = libraryDirs---- | Find all the C-compiler options in these and the preload packages-getPackageExtraCcOpts :: DynFlags -> [PreloadUnitId] -> IO [String]-getPackageExtraCcOpts dflags pkgs = do-  ps <- getPreloadPackagesAnd dflags pkgs-  return (concatMap ccOptions ps)---- | Find all the package framework paths in these and the preload packages-getPackageFrameworkPath  :: DynFlags -> [PreloadUnitId] -> IO [String]-getPackageFrameworkPath dflags pkgs = do-  ps <- getPreloadPackagesAnd dflags pkgs-  return (ordNub (filter notNull (concatMap frameworkDirs ps)))---- | Find all the package frameworks in these and the preload packages-getPackageFrameworks  :: DynFlags -> [PreloadUnitId] -> IO [String]-getPackageFrameworks dflags pkgs = do-  ps <- getPreloadPackagesAnd dflags pkgs-  return (concatMap frameworks ps)---- -------------------------------------------------------------------------------- Package Utils---- | Takes a 'ModuleName', and if the module is in any package returns--- list of modules which take that name.-lookupModuleInAllPackages :: DynFlags-                          -> ModuleName-                          -> [(Module, UnitInfo)]-lookupModuleInAllPackages dflags m-  = case lookupModuleWithSuggestions dflags m Nothing of-      LookupFound a b -> [(a,b)]-      LookupMultiple rs -> map f rs-        where f (m,_) = (m, expectJust "lookupModule" (lookupUnit dflags-                                                         (moduleUnitId m)))-      _ -> []---- | The result of performing a lookup-data LookupResult =-    -- | Found the module uniquely, nothing else to do-    LookupFound Module UnitInfo-    -- | Multiple modules with the same name in scope-  | LookupMultiple [(Module, ModuleOrigin)]-    -- | No modules found, but there were some hidden ones with-    -- an exact name match.  First is due to package hidden, second-    -- is due to module being hidden-  | LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]-    -- | No modules found, but there were some unusable ones with-    -- an exact name match-  | LookupUnusable [(Module, ModuleOrigin)]-    -- | Nothing found, here are some suggested different names-  | LookupNotFound [ModuleSuggestion] -- suggestions--data ModuleSuggestion = SuggestVisible ModuleName Module ModuleOrigin-                      | SuggestHidden ModuleName Module ModuleOrigin--lookupModuleWithSuggestions :: DynFlags-                            -> ModuleName-                            -> Maybe FastString-                            -> LookupResult-lookupModuleWithSuggestions dflags-  = lookupModuleWithSuggestions' dflags-        (moduleNameProvidersMap (pkgState dflags))--lookupPluginModuleWithSuggestions :: DynFlags-                                  -> ModuleName-                                  -> Maybe FastString-                                  -> LookupResult-lookupPluginModuleWithSuggestions dflags-  = lookupModuleWithSuggestions' dflags-        (pluginModuleNameProvidersMap (pkgState dflags))--lookupModuleWithSuggestions' :: DynFlags-                            -> ModuleNameProvidersMap-                            -> ModuleName-                            -> Maybe FastString-                            -> LookupResult-lookupModuleWithSuggestions' dflags mod_map m mb_pn-  = case Map.lookup m mod_map of-        Nothing -> LookupNotFound suggestions-        Just xs ->-          case foldl' classify ([],[],[], []) (Map.toList xs) of-            ([], [], [], []) -> LookupNotFound suggestions-            (_, _, _, [(m, _)])             -> LookupFound m (mod_unit m)-            (_, _, _, exposed@(_:_))        -> LookupMultiple exposed-            ([], [], unusable@(_:_), [])    -> LookupUnusable unusable-            (hidden_pkg, hidden_mod, _, []) ->-              LookupHidden hidden_pkg hidden_mod-  where-    classify (hidden_pkg, hidden_mod, unusable, exposed) (m, origin0) =-      let origin = filterOrigin mb_pn (mod_unit m) origin0-          x = (m, origin)-      in case origin of-          ModHidden-            -> (hidden_pkg, x:hidden_mod, unusable, exposed)-          ModUnusable _-            -> (hidden_pkg, hidden_mod, x:unusable, exposed)-          _ | originEmpty origin-            -> (hidden_pkg,   hidden_mod, unusable, exposed)-            | originVisible origin-            -> (hidden_pkg, hidden_mod, unusable, x:exposed)-            | otherwise-            -> (x:hidden_pkg, hidden_mod, unusable, exposed)--    unit_lookup p = lookupUnit dflags p `orElse` pprPanic "lookupModuleWithSuggestions" (ppr p <+> ppr m)-    mod_unit = unit_lookup . moduleUnitId--    -- Filters out origins which are not associated with the given package-    -- qualifier.  No-op if there is no package qualifier.  Test if this-    -- excluded all origins with 'originEmpty'.-    filterOrigin :: Maybe FastString-                 -> UnitInfo-                 -> ModuleOrigin-                 -> ModuleOrigin-    filterOrigin Nothing _ o = o-    filterOrigin (Just pn) pkg o =-      case o of-          ModHidden -> if go pkg then ModHidden else mempty-          (ModUnusable _) -> if go pkg then o else mempty-          ModOrigin { fromOrigPackage = e, fromExposedReexport = res,-                      fromHiddenReexport = rhs }-            -> ModOrigin {-                  fromOrigPackage = if go pkg then e else Nothing-                , fromExposedReexport = filter go res-                , fromHiddenReexport = filter go rhs-                , fromPackageFlag = False -- always excluded-                }-      where go pkg = pn == fsPackageName pkg--    suggestions-      | gopt Opt_HelpfulErrors dflags =-           fuzzyLookup (moduleNameString m) all_mods-      | otherwise = []--    all_mods :: [(String, ModuleSuggestion)]     -- All modules-    all_mods = sortBy (comparing fst) $-        [ (moduleNameString m, suggestion)-        | (m, e) <- Map.toList (moduleNameProvidersMap (pkgState dflags))-        , suggestion <- map (getSuggestion m) (Map.toList e)-        ]-    getSuggestion name (mod, origin) =-        (if originVisible origin then SuggestVisible else SuggestHidden)-            name mod origin--listVisibleModuleNames :: DynFlags -> [ModuleName]-listVisibleModuleNames dflags =-    map fst (filter visible (Map.toList (moduleNameProvidersMap (pkgState dflags))))-  where visible (_, ms) = any originVisible (Map.elems ms)---- | Find all the 'UnitInfo' in both the preload packages from 'DynFlags' and corresponding to the list of--- 'UnitInfo's-getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [UnitInfo]-getPreloadPackagesAnd dflags pkgids0 =-  let-      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 = unitInfoMap state-      preload = preloadPackages state-      pairs = zip pkgids (repeat Nothing)-  in do-  all_pkgs <- throwErr dflags (foldM (add_package dflags pkg_map) preload pairs)-  return (map (getInstalledPackageDetails dflags) all_pkgs)---- Takes a list of packages, and returns the list with dependencies included,--- in reverse dependency order (a package appears before those it depends on).-closeDeps :: DynFlags-          -> UnitInfoMap-          -> [(InstalledUnitId, Maybe InstalledUnitId)]-          -> IO [InstalledUnitId]-closeDeps dflags pkg_map ps-    = throwErr dflags (closeDepsErr dflags pkg_map ps)--throwErr :: DynFlags -> MaybeErr MsgDoc a -> IO a-throwErr dflags m-              = case m of-                Failed e    -> throwGhcExceptionIO (CmdLineError (showSDoc dflags e))-                Succeeded r -> return r--closeDepsErr :: DynFlags-             -> UnitInfoMap-             -> [(InstalledUnitId,Maybe InstalledUnitId)]-             -> MaybeErr MsgDoc [InstalledUnitId]-closeDepsErr dflags pkg_map ps = foldM (add_package dflags pkg_map) [] ps---- internal helper-add_package :: DynFlags-            -> UnitInfoMap-            -> [PreloadUnitId]-            -> (PreloadUnitId,Maybe PreloadUnitId)-            -> MaybeErr MsgDoc [PreloadUnitId]-add_package dflags pkg_db ps (p, mb_parent)-  | p `elem` ps = return ps     -- Check if we've already added this package-  | otherwise =-      case lookupInstalledPackage' pkg_db p of-        Nothing -> Failed (missingPackageMsg p <>-                           missingDependencyMsg mb_parent)-        Just pkg -> do-           -- Add the package's dependents also-           ps' <- foldM add_unit_key ps (depends pkg)-           return (p : ps')-          where-            add_unit_key ps key-              = add_package dflags pkg_db ps (key, Just p)--missingPackageMsg :: Outputable pkgid => pkgid -> SDoc-missingPackageMsg p = text "unknown package:" <+> ppr p--missingDependencyMsg :: Maybe InstalledUnitId -> SDoc-missingDependencyMsg Nothing = Outputable.empty-missingDependencyMsg (Just parent)-  = space <> parens (text "dependency of" <+> ftext (installedUnitIdFS parent))---- -------------------------------------------------------------------------------componentIdString :: DynFlags -> ComponentId -> Maybe String-componentIdString dflags cid = do-    conf <- lookupInstalledPackage dflags (componentIdToInstalledUnitId cid)-    return $-        case sourceLibName conf of-            Nothing -> sourcePackageIdString conf-            Just (PackageName libname) ->-                packageNameString conf-                    ++ "-" ++ showVersion (packageVersion conf)-                    ++ ":" ++ unpackFS libname--displayInstalledUnitId :: DynFlags -> InstalledUnitId -> Maybe String-displayInstalledUnitId dflags uid =-    fmap sourcePackageIdString (lookupInstalledPackage dflags uid)---- | Will the 'Name' come from a dynamically linked library?-isDllName :: DynFlags -> Module -> Name -> Bool--- Despite the "dll", I think this function just means that--- the symbol comes from another dynamically-linked package,--- and applies on all platforms, not just Windows-isDllName dflags this_mod name-  | not (gopt Opt_ExternalDynamicRefs dflags) = False-  | Just mod <- nameModule_maybe name-    -- Issue #8696 - when GHC is dynamically linked, it will attempt-    -- to load the dynamic dependencies of object files at compile-    -- time for things like QuasiQuotes or-    -- TemplateHaskell. Unfortunately, this interacts badly with-    -- intra-package linking, because we don't generate indirect-    -- (dynamic) symbols for intra-package calls. This means that if a-    -- module with an intra-package call is loaded without its-    -- dependencies, then GHC fails to link. This is the cause of #-    ---    -- In the mean time, always force dynamic indirections to be-    -- generated: when the module name isn't the module being-    -- compiled, references are dynamic.-    = 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. referring 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---- -------------------------------------------------------------------------------- Displaying packages---- | Show (very verbose) package info-pprPackages :: DynFlags -> SDoc-pprPackages = pprPackagesWith pprUnitInfo--pprPackagesWith :: (UnitInfo -> SDoc) -> DynFlags -> SDoc-pprPackagesWith pprIPI dflags =-    vcat (intersperse (text "---") (map pprIPI (listUnitInfoMap dflags)))---- | Show simplified package info.------ The idea is to only print package id, and any information that might--- be different from the package databases (exposure, trust)-pprPackagesSimple :: DynFlags -> SDoc-pprPackagesSimple = pprPackagesWith pprIPI-    where pprIPI ipi = let i = installedUnitIdFS (unitId ipi)-                           e = if exposed ipi then text "E" else text " "-                           t = if trusted ipi then text "T" else text " "-                       in e <> t <> text "  " <> ftext i---- | Show the mapping of modules to where they come from.-pprModuleMap :: ModuleNameProvidersMap -> SDoc-pprModuleMap mod_map =-  vcat (map pprLine (Map.toList mod_map))-    where-      pprLine (m,e) = ppr m $$ nest 50 (vcat (map (pprEntry m) (Map.toList e)))-      pprEntry :: Outputable a => ModuleName -> (Module, a) -> SDoc-      pprEntry m (m',o)-        | m == moduleName m' = ppr (moduleUnitId m') <+> parens (ppr o)-        | otherwise = ppr m' <+> parens (ppr o)--fsPackageName :: UnitInfo -> FastString-fsPackageName = mkFastString . packageNameString---- | Given a fully instantiated 'UnitId', improve it into a--- 'InstalledUnitId' if we can find it in the package database.-improveUnitId :: UnitInfoMap -> UnitId -> UnitId-improveUnitId _ uid@(DefiniteUnitId _) = uid -- short circuit-improveUnitId pkg_map uid =-    -- Do NOT lookup indefinite ones, they won't be useful!-    case lookupUnit' False pkg_map uid of-        Nothing  -> uid-        Just pkg ->-            -- Do NOT improve if the indefinite unit id is not-            -- part of the closure unique set.  See-            -- Note [UnitId to InstalledUnitId improvement]-            if installedUnitInfoId pkg `elementOfUniqSet` preloadClosure pkg_map-                then packageConfigId pkg-                else uid---- | Retrieve the 'UnitInfoMap' from 'DynFlags'; used--- in the @hs-boot@ loop-breaker.-getUnitInfoMap :: DynFlags -> UnitInfoMap-getUnitInfoMap = unitInfoMap . pkgState

− compiler/main/Packages.hs-boot

@@ -1,12 +0,0 @@-module Packages where-import GhcPrelude-import {-# SOURCE #-} DynFlags(DynFlags)-import {-# SOURCE #-} Module(ComponentId, UnitId, InstalledUnitId)-data PackageState-data UnitInfoMap-data PackageDatabase-emptyPackageState :: PackageState-componentIdString :: DynFlags -> ComponentId -> Maybe String-displayInstalledUnitId :: DynFlags -> InstalledUnitId -> Maybe String-improveUnitId :: UnitInfoMap -> UnitId -> UnitId-getUnitInfoMap :: DynFlags -> UnitInfoMap

− compiler/main/PipelineMonad.hs

@@ -1,122 +0,0 @@-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE NamedFieldPuns #-}--- | The CompPipeline monad and associated ops------ Defined in separate module so that it can safely be imported from Hooks-module PipelineMonad (-    CompPipeline(..), evalP-  , PhasePlus(..)-  , PipeEnv(..), PipeState(..), PipelineOutput(..)-  , getPipeEnv, getPipeState, setDynFlags, setModLocation, setForeignOs, setIface-  , pipeStateDynFlags, pipeStateModIface-  ) where--import GhcPrelude--import MonadUtils-import Outputable-import DynFlags-import DriverPhases-import HscTypes-import Module-import FileCleanup (TempFileLifetime)--import Control.Monad--newtype CompPipeline a = P { unP :: PipeEnv -> PipeState -> IO (PipeState, a) }-    deriving (Functor)--evalP :: CompPipeline a -> PipeEnv -> PipeState -> IO (PipeState, a)-evalP (P f) env st = f env st--instance Applicative CompPipeline where-    pure a = P $ \_env state -> return (state, a)-    (<*>) = ap--instance Monad CompPipeline where-  P m >>= k = P $ \env state -> do (state',a) <- m env state-                                   unP (k a) env state'--instance MonadIO CompPipeline where-    liftIO m = P $ \_env state -> do a <- m; return (state, a)--data PhasePlus = RealPhase Phase-               | HscOut HscSource ModuleName HscStatus--instance Outputable PhasePlus where-    ppr (RealPhase p) = ppr p-    ppr (HscOut {}) = text "HscOut"---- -------------------------------------------------------------------------------- The pipeline uses a monad to carry around various bits of information---- PipeEnv: invariant information passed down-data PipeEnv = PipeEnv {-       stop_phase   :: Phase,       -- ^ Stop just before this phase-       src_filename :: String,      -- ^ basename of original input source-       src_basename :: String,      -- ^ basename of original input source-       src_suffix   :: String,      -- ^ its extension-       output_spec  :: PipelineOutput -- ^ says where to put the pipeline output-  }---- PipeState: information that might change during a pipeline run-data PipeState = PipeState {-       hsc_env   :: HscEnv,-          -- ^ only the DynFlags change in the HscEnv.  The DynFlags change-          -- at various points, for example when we read the OPTIONS_GHC-          -- pragmas in the Cpp phase.-       maybe_loc :: Maybe ModLocation,-          -- ^ the ModLocation.  This is discovered during compilation,-          -- in the Hsc phase where we read the module header.-       foreign_os :: [FilePath],-         -- ^ additional object files resulting from compiling foreign-         -- code. They come from two sources: foreign stubs, and-         -- add{C,Cxx,Objc,Objcxx}File from template haskell-       iface :: Maybe (ModIface, ModDetails)-         -- ^ Interface generated by HscOut phase. Only available after the-         -- phase runs.-  }--pipeStateDynFlags :: PipeState -> DynFlags-pipeStateDynFlags = hsc_dflags . hsc_env--pipeStateModIface :: PipeState -> Maybe (ModIface, ModDetails)-pipeStateModIface = iface--data PipelineOutput-  = Temporary TempFileLifetime-        -- ^ Output should be to a temporary file: we're going to-        -- run more compilation steps on this output later.-  | Persistent-        -- ^ We want a persistent file, i.e. a file in the current directory-        -- derived from the input filename, but with the appropriate extension.-        -- eg. in "ghc -c Foo.hs" the output goes into ./Foo.o.-  | SpecificFile-        -- ^ The output must go into the specific outputFile in DynFlags.-        -- We don't store the filename in the constructor as it changes-        -- when doing -dynamic-too.-    deriving Show--getPipeEnv :: CompPipeline PipeEnv-getPipeEnv = P $ \env state -> return (state, env)--getPipeState :: CompPipeline PipeState-getPipeState = P $ \_env state -> return (state, state)--instance HasDynFlags CompPipeline where-    getDynFlags = P $ \_env state -> return (state, hsc_dflags (hsc_env state))--setDynFlags :: DynFlags -> CompPipeline ()-setDynFlags dflags = P $ \_env state ->-  return (state{hsc_env= (hsc_env state){ hsc_dflags = dflags }}, ())--setModLocation :: ModLocation -> CompPipeline ()-setModLocation loc = P $ \_env state ->-  return (state{ maybe_loc = Just loc }, ())--setForeignOs :: [FilePath] -> CompPipeline ()-setForeignOs os = P $ \_env state ->-  return (state{ foreign_os = os }, ())--setIface :: ModIface -> ModDetails -> CompPipeline ()-setIface iface details = P $ \_env state -> return (state{ iface = Just (iface, details) }, ())

− compiler/main/Plugins.hs

@@ -1,264 +0,0 @@-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE CPP #-}---- | Definitions for writing /plugins/ for GHC. Plugins can hook into--- several areas of the compiler. See the 'Plugin' type. These plugins--- include type-checker plugins, source plugins, and core-to-core plugins.--module Plugins (-      -- * Plugins-      Plugin(..)-    , defaultPlugin-    , CommandLineOption-      -- ** Recompilation checking-    , purePlugin, impurePlugin, flagRecompile-    , PluginRecompile(..)--      -- * Plugin types-      -- ** Frontend plugins-    , FrontendPlugin(..), defaultFrontendPlugin, FrontendPluginAction-      -- ** Core plugins-      -- | Core plugins allow plugins to register as a Core-to-Core pass.-    , CorePlugin-      -- ** Typechecker plugins-      -- | Typechecker plugins allow plugins to provide evidence to the-      -- typechecker.-    , TcPlugin-      -- ** Source plugins-      -- | GHC offers a number of points where plugins can access and modify its-      -- front-end (\"source\") representation. These include:-      ---      -- - access to the parser result with 'parsedResultAction'-      -- - access to the renamed AST with 'renamedResultAction'-      -- - access to the typechecked AST with 'typeCheckResultAction'-      -- - access to the Template Haskell splices with 'spliceRunAction'-      -- - access to loaded interface files with 'interfaceLoadAction'-      ---    , keepRenamedSource-      -- ** Hole fit plugins-      -- | hole fit plugins allow plugins to change the behavior of valid hole-      -- fit suggestions-    , HoleFitPluginR--      -- * Internal-    , PluginWithArgs(..), plugins, pluginRecompile'-    , LoadedPlugin(..), lpModuleName-    , StaticPlugin(..)-    , mapPlugins, withPlugins, withPlugins_-    ) where--import GhcPrelude--import {-# SOURCE #-} CoreMonad ( CoreToDo, CoreM )-import qualified TcRnTypes-import TcRnTypes ( TcGblEnv, IfM, TcM, tcg_rn_decls, tcg_rn_exports  )-import TcHoleFitTypes ( HoleFitPluginR )-import GHC.Hs-import DynFlags-import HscTypes-import GhcMonad-import DriverPhases-import Module ( ModuleName, Module(moduleName))-import Fingerprint-import Data.List-import Outputable (Outputable(..), text, (<+>))----Qualified import so we can define a Semigroup instance--- but it doesn't clash with Outputable.<>-import qualified Data.Semigroup--import Control.Monad---- | Command line options gathered from the -PModule.Name:stuff syntax--- are given to you as this type-type CommandLineOption = String---- | 'Plugin' is the compiler plugin data type. Try to avoid--- constructing one of these directly, and just modify some fields of--- 'defaultPlugin' instead: this is to try and preserve source-code--- compatibility when we add fields to this.------ Nonetheless, this API is preliminary and highly likely to change in--- the future.-data Plugin = Plugin {-    installCoreToDos :: CorePlugin-    -- ^ Modify the Core pipeline that will be used for compilation.-    -- This is called as the Core pipeline is built for every module-    -- being compiled, and plugins get the opportunity to modify the-    -- pipeline in a nondeterministic order.-  , tcPlugin :: TcPlugin-    -- ^ An optional typechecker plugin, which may modify the-    -- behaviour of the constraint solver.-  , holeFitPlugin :: HoleFitPlugin-    -- ^ An optional plugin to handle hole fits, which may re-order-    --   or change the list of valid hole fits and refinement hole fits.-  , dynflagsPlugin :: [CommandLineOption] -> DynFlags -> IO DynFlags-    -- ^ An optional plugin to update 'DynFlags', right after-    --   plugin loading. This can be used to register hooks-    --   or tweak any field of 'DynFlags' before doing-    --   actual work on a module.-    ---    --   @since 8.10.1-  , pluginRecompile :: [CommandLineOption] -> IO PluginRecompile-    -- ^ Specify how the plugin should affect recompilation.-  , parsedResultAction :: [CommandLineOption] -> ModSummary -> HsParsedModule-                            -> Hsc HsParsedModule-    -- ^ Modify the module when it is parsed. This is called by-    -- HscMain when the parsing is successful.-  , renamedResultAction :: [CommandLineOption] -> TcGblEnv-                                -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)-    -- ^ Modify each group after it is renamed. This is called after each-    -- `HsGroup` has been renamed.-  , typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv-                               -> TcM TcGblEnv-    -- ^ Modify the module when it is type checked. This is called at the-    -- very end of typechecking.-  , spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc-                         -> TcM (LHsExpr GhcTc)-    -- ^ Modify the TH splice or quasiqoute before it is run.-  , interfaceLoadAction :: forall lcl . [CommandLineOption] -> ModIface-                                          -> IfM lcl ModIface-    -- ^ Modify an interface that have been loaded. This is called by-    -- GHC.Iface.Load when an interface is successfully loaded. Not applied to-    -- the loading of the plugin interface. Tools that rely on information from-    -- modules other than the currently compiled one should implement this-    -- function.-  }---- Note [Source plugins]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- The `Plugin` datatype have been extended by fields that allow access to the--- different inner representations that are generated during the compilation--- process. These fields are `parsedResultAction`, `renamedResultAction`,--- `typeCheckResultAction`, `spliceRunAction` and `interfaceLoadAction`.------ The main purpose of these plugins is to help tool developers. They allow--- development tools to extract the information about the source code of a big--- Haskell project during the normal build procedure. In this case the plugin--- acts as the tools access point to the compiler that can be controlled by--- compiler flags. This is important because the manipulation of compiler flags--- is supported by most build environment.------ For the full discussion, check the full proposal at:--- https://gitlab.haskell.org/ghc/ghc/wikis/extended-plugins-proposal--data PluginWithArgs = PluginWithArgs-  { paPlugin :: Plugin-    -- ^ the actual callable plugin-  , paArguments :: [CommandLineOption]-    -- ^ command line arguments for the plugin-  }---- | A plugin with its arguments. The result of loading the plugin.-data LoadedPlugin = LoadedPlugin-  { lpPlugin :: PluginWithArgs-  -- ^ the actual plugin together with its commandline arguments-  , lpModule :: ModIface-  -- ^ the module containing the plugin-  }---- | A static plugin with its arguments. For registering compiled-in plugins--- through the GHC API.-data StaticPlugin = StaticPlugin-  { spPlugin :: PluginWithArgs-  -- ^ the actual plugin together with its commandline arguments-  }--lpModuleName :: LoadedPlugin -> ModuleName-lpModuleName = moduleName . mi_module . lpModule--pluginRecompile' :: PluginWithArgs -> IO PluginRecompile-pluginRecompile' (PluginWithArgs plugin args) = pluginRecompile plugin args--data PluginRecompile = ForceRecompile | NoForceRecompile | MaybeRecompile Fingerprint--instance Outputable PluginRecompile where-  ppr ForceRecompile = text "ForceRecompile"-  ppr NoForceRecompile = text "NoForceRecompile"-  ppr (MaybeRecompile fp) = text "MaybeRecompile" <+> ppr fp--instance Semigroup PluginRecompile where-  ForceRecompile <> _ = ForceRecompile-  NoForceRecompile <> r = r-  MaybeRecompile fp <> NoForceRecompile   = MaybeRecompile fp-  MaybeRecompile fp <> MaybeRecompile fp' = MaybeRecompile (fingerprintFingerprints [fp, fp'])-  MaybeRecompile _fp <> ForceRecompile     = ForceRecompile--instance Monoid PluginRecompile where-  mempty = NoForceRecompile--type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]-type TcPlugin = [CommandLineOption] -> Maybe TcRnTypes.TcPlugin-type HoleFitPlugin = [CommandLineOption] -> Maybe HoleFitPluginR--purePlugin, impurePlugin, flagRecompile :: [CommandLineOption] -> IO PluginRecompile-purePlugin _args = return NoForceRecompile--impurePlugin _args = return ForceRecompile--flagRecompile =-  return . MaybeRecompile . fingerprintFingerprints . map fingerprintString . sort---- | Default plugin: does nothing at all, except for marking that safe--- inference has failed unless @-fplugin-trustworthy@ is passed. For--- compatibility reason you should base all your plugin definitions on this--- default value.-defaultPlugin :: Plugin-defaultPlugin = Plugin {-        installCoreToDos      = const return-      , tcPlugin              = const Nothing-      , holeFitPlugin         = const Nothing-      , dynflagsPlugin        = const return-      , pluginRecompile       = impurePlugin-      , renamedResultAction   = \_ env grp -> return (env, grp)-      , parsedResultAction    = \_ _ -> return-      , typeCheckResultAction = \_ _ -> return-      , spliceRunAction       = \_ -> return-      , interfaceLoadAction   = \_ -> return-    }----- | A renamer plugin which mades the renamed source available in--- a typechecker plugin.-keepRenamedSource :: [CommandLineOption] -> TcGblEnv-                  -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)-keepRenamedSource _ gbl_env group =-  return (gbl_env { tcg_rn_decls = update (tcg_rn_decls gbl_env)-                  , tcg_rn_exports = update_exports (tcg_rn_exports gbl_env) }, group)-  where-    update_exports Nothing = Just []-    update_exports m = m--    update Nothing = Just emptyRnGroup-    update m       = m---type PluginOperation m a = Plugin -> [CommandLineOption] -> a -> m a-type ConstPluginOperation m a = Plugin -> [CommandLineOption] -> a -> m ()--plugins :: DynFlags -> [PluginWithArgs]-plugins df =-  map lpPlugin (cachedPlugins df) ++-  map spPlugin (staticPlugins df)---- | Perform an operation by using all of the plugins in turn.-withPlugins :: Monad m => DynFlags -> PluginOperation m a -> a -> m a-withPlugins df transformation input = foldM go input (plugins df)-  where-    go arg (PluginWithArgs p opts) = transformation p opts arg--mapPlugins :: DynFlags -> (Plugin -> [CommandLineOption] -> a) -> [a]-mapPlugins df f = map (\(PluginWithArgs p opts) -> f p opts) (plugins df)---- | Perform a constant operation by using all of the plugins in turn.-withPlugins_ :: Monad m => DynFlags -> ConstPluginOperation m a -> a -> m ()-withPlugins_ df transformation input-  = mapM_ (\(PluginWithArgs p opts) -> transformation p opts input)-          (plugins df)--type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()-data FrontendPlugin = FrontendPlugin {-      frontend :: FrontendPluginAction-    }-defaultFrontendPlugin :: FrontendPlugin-defaultFrontendPlugin = FrontendPlugin { frontend = \_ _ -> return () }

− compiler/main/Plugins.hs-boot

@@ -1,10 +0,0 @@--- The plugins datatype is stored in DynFlags, so it needs to be--- exposed without importing all of its implementation.-module Plugins where--import GhcPrelude ()--data Plugin--data LoadedPlugin-data StaticPlugin

− compiler/nativeGen/Reg.hs

@@ -1,241 +0,0 @@--- | An architecture independent description of a register.---      This needs to stay architecture independent because it is used---      by NCGMonad and the register allocators, which are shared---      by all architectures.----module Reg (-        RegNo,-        Reg(..),-        regPair,-        regSingle,-        isRealReg,      takeRealReg,-        isVirtualReg,   takeVirtualReg,--        VirtualReg(..),-        renameVirtualReg,-        classOfVirtualReg,-        getHiVirtualRegFromLo,-        getHiVRegFromLo,--        RealReg(..),-        regNosOfRealReg,-        realRegsAlias,--        liftPatchFnToRegReg-)--where--import GhcPrelude--import Outputable-import Unique-import RegClass-import Data.List---- | An identifier for a primitive real machine register.-type RegNo-        = Int---- VirtualRegs are virtual registers.  The register allocator will---      eventually have to map them into RealRegs, or into spill slots.------      VirtualRegs are allocated on the fly, usually to represent a single---      value in the abstract assembly code (i.e. dynamic registers are---      usually single assignment).------      The  single assignment restriction isn't necessary to get correct code,---      although a better register allocation will result if single---      assignment is used -- because the allocator maps a VirtualReg into---      a single RealReg, even if the VirtualReg has multiple live ranges.------      Virtual regs can be of either class, so that info is attached.----data VirtualReg-        = VirtualRegI  {-# UNPACK #-} !Unique-        | VirtualRegHi {-# UNPACK #-} !Unique  -- High part of 2-word register-        | VirtualRegF  {-# UNPACK #-} !Unique-        | VirtualRegD  {-# UNPACK #-} !Unique--        deriving (Eq, Show)---- This is laborious, but necessary. We can't derive Ord because--- Unique doesn't have an Ord instance. Note nonDetCmpUnique in the--- implementation. See Note [No Ord for Unique]--- This is non-deterministic but we do not currently support deterministic--- code-generation. See Note [Unique Determinism and code generation]-instance Ord VirtualReg where-  compare (VirtualRegI a) (VirtualRegI b) = nonDetCmpUnique a b-  compare (VirtualRegHi a) (VirtualRegHi b) = nonDetCmpUnique a b-  compare (VirtualRegF a) (VirtualRegF b) = nonDetCmpUnique a b-  compare (VirtualRegD a) (VirtualRegD b) = nonDetCmpUnique a b--  compare VirtualRegI{} _ = LT-  compare _ VirtualRegI{} = GT-  compare VirtualRegHi{} _ = LT-  compare _ VirtualRegHi{} = GT-  compare VirtualRegF{} _ = LT-  compare _ VirtualRegF{} = GT----instance Uniquable VirtualReg where-        getUnique reg-         = case reg of-                VirtualRegI u   -> u-                VirtualRegHi u  -> u-                VirtualRegF u   -> u-                VirtualRegD u   -> u--instance Outputable VirtualReg where-        ppr reg-         = case reg of-                VirtualRegI  u  -> text "%vI_"   <> pprUniqueAlways u-                VirtualRegHi u  -> text "%vHi_"  <> pprUniqueAlways u-                -- this code is kinda wrong on x86-                -- because float and double occupy the same register set-                -- namely SSE2 register xmm0 .. xmm15-                VirtualRegF  u  -> text "%vFloat_"   <> pprUniqueAlways u-                VirtualRegD  u  -> text "%vDouble_"   <> pprUniqueAlways u----renameVirtualReg :: Unique -> VirtualReg -> VirtualReg-renameVirtualReg u r- = case r of-        VirtualRegI _   -> VirtualRegI  u-        VirtualRegHi _  -> VirtualRegHi u-        VirtualRegF _   -> VirtualRegF  u-        VirtualRegD _   -> VirtualRegD  u---classOfVirtualReg :: VirtualReg -> RegClass-classOfVirtualReg vr- = case vr of-        VirtualRegI{}   -> RcInteger-        VirtualRegHi{}  -> RcInteger-        VirtualRegF{}   -> RcFloat-        VirtualRegD{}   -> RcDouble------ Determine the upper-half vreg for a 64-bit quantity on a 32-bit platform--- when supplied with the vreg for the lower-half of the quantity.--- (NB. Not reversible).-getHiVirtualRegFromLo :: VirtualReg -> VirtualReg-getHiVirtualRegFromLo reg- = case reg of-        -- makes a pseudo-unique with tag 'H'-        VirtualRegI u   -> VirtualRegHi (newTagUnique u 'H')-        _               -> panic "Reg.getHiVirtualRegFromLo"--getHiVRegFromLo :: Reg -> Reg-getHiVRegFromLo reg- = case reg of-        RegVirtual  vr  -> RegVirtual (getHiVirtualRegFromLo vr)-        RegReal _       -> panic "Reg.getHiVRegFromLo"------------------------------------------------------------------------------------------ | RealRegs are machine regs which are available for allocation, in---      the usual way.  We know what class they are, because that's part of---      the processor's architecture.------      RealRegPairs are pairs of real registers that are allocated together---      to hold a larger value, such as with Double regs on SPARC.----data RealReg-        = RealRegSingle {-# UNPACK #-} !RegNo-        | RealRegPair   {-# UNPACK #-} !RegNo {-# UNPACK #-} !RegNo-        deriving (Eq, Show, Ord)--instance Uniquable RealReg where-        getUnique reg-         = case reg of-                RealRegSingle i         -> mkRegSingleUnique i-                RealRegPair r1 r2       -> mkRegPairUnique (r1 * 65536 + r2)--instance Outputable RealReg where-        ppr reg-         = case reg of-                RealRegSingle i         -> text "%r"  <> int i-                RealRegPair r1 r2       -> text "%r(" <> int r1-                                           <> vbar <> int r2 <> text ")"--regNosOfRealReg :: RealReg -> [RegNo]-regNosOfRealReg rr- = case rr of-        RealRegSingle r1        -> [r1]-        RealRegPair   r1 r2     -> [r1, r2]---realRegsAlias :: RealReg -> RealReg -> Bool-realRegsAlias rr1 rr2-        = not $ null $ intersect (regNosOfRealReg rr1) (regNosOfRealReg rr2)------------------------------------------------------------------------------------- | A register, either virtual or real-data Reg-        = RegVirtual !VirtualReg-        | RegReal    !RealReg-        deriving (Eq, Ord)--regSingle :: RegNo -> Reg-regSingle regNo         = RegReal $ RealRegSingle regNo--regPair :: RegNo -> RegNo -> Reg-regPair regNo1 regNo2   = RegReal $ RealRegPair regNo1 regNo2----- We like to have Uniques for Reg so that we can make UniqFM and UniqSets--- in the register allocator.-instance Uniquable Reg where-        getUnique reg-         = case reg of-                RegVirtual vr   -> getUnique vr-                RegReal    rr   -> getUnique rr---- | Print a reg in a generic manner---      If you want the architecture specific names, then use the pprReg---      function from the appropriate Ppr module.-instance Outputable Reg where-        ppr reg-         = case reg of-                RegVirtual vr   -> ppr vr-                RegReal    rr   -> ppr rr---isRealReg :: Reg -> Bool-isRealReg reg- = case reg of-        RegReal _       -> True-        RegVirtual _    -> False--takeRealReg :: Reg -> Maybe RealReg-takeRealReg reg- = case reg of-        RegReal rr      -> Just rr-        _               -> Nothing---isVirtualReg :: Reg -> Bool-isVirtualReg reg- = case reg of-        RegReal _       -> False-        RegVirtual _    -> True--takeVirtualReg :: Reg -> Maybe VirtualReg-takeVirtualReg reg- = case reg of-        RegReal _       -> Nothing-        RegVirtual vr   -> Just vr----- | The patch function supplied by the allocator maps VirtualReg to RealReg---      regs, but sometimes we want to apply it to plain old Reg.----liftPatchFnToRegReg  :: (VirtualReg -> RealReg) -> (Reg -> Reg)-liftPatchFnToRegReg patchF reg- = case reg of-        RegVirtual vr   -> RegReal (patchF vr)-        RegReal _       -> reg

− compiler/nativeGen/RegClass.hs

@@ -1,32 +0,0 @@--- | An architecture independent description of a register's class.-module RegClass-        ( RegClass (..) )--where--import GhcPrelude--import  Outputable-import  Unique----- | The class of a register.---      Used in the register allocator.---      We treat all registers in a class as being interchangeable.----data RegClass-        = RcInteger-        | RcFloat-        | RcDouble-        deriving Eq---instance Uniquable RegClass where-    getUnique RcInteger = mkRegClassUnique 0-    getUnique RcFloat   = mkRegClassUnique 1-    getUnique RcDouble  = mkRegClassUnique 2--instance Outputable RegClass where-    ppr RcInteger       = Outputable.text "I"-    ppr RcFloat         = Outputable.text "F"-    ppr RcDouble        = Outputable.text "D"

compiler/parser/ApiAnnotation.hs view

@@ -3,7 +3,7 @@ module ApiAnnotation (   getAnnotation, getAndRemoveAnnotation,   getAnnotationComments,getAndRemoveAnnotationComments,-  ApiAnns,+  ApiAnns(..),   ApiAnnKey,   AnnKeywordId(..),   AnnotationComment(..),@@ -41,8 +41,13 @@  The full ApiAnns type is -> type ApiAnns = ( Map.Map ApiAnnKey [SrcSpan]                  -- non-comments->                , Map.Map SrcSpan [Located AnnotationComment]) -- comments+> data ApiAnns =+>  ApiAnns+>    { apiAnnItems :: Map.Map ApiAnnKey [RealSrcSpan],+>      apiAnnEofPos :: Maybe RealSrcSpan,+>      apiAnnComments :: Map.Map RealSrcSpan [RealLocated AnnotationComment],+>      apiAnnRogueComments :: [RealLocated AnnotationComment]+>    }  NON-COMMENT ELEMENTS @@ -52,13 +57,13 @@ needs to be associated with its location in the original source code.  Consequently, the structure that records non-comment elements is logically-a two level map, from the SrcSpan of the AST element containing it, to+a two level map, from the RealSrcSpan of the AST element containing it, to a map from keywords ('AnnKeyWord') to all locations of the keyword directly in the AST element: -> type ApiAnnKey = (SrcSpan,AnnKeywordId)+> type ApiAnnKey = (RealSrcSpan,AnnKeywordId) >-> Map.Map ApiAnnKey [SrcSpan]+> Map.Map ApiAnnKey [RealSrcSpan]  So @@ -87,16 +92,16 @@ We associate comments with the lowest (most specific) AST element enclosing them: -> Map.Map SrcSpan [Located AnnotationComment]+> Map.Map RealSrcSpan [RealLocated AnnotationComment]  PARSER STATE  There are three fields in PState (the parser state) which play a role with annotations. ->  annotations :: [(ApiAnnKey,[SrcSpan])],->  comment_q :: [Located AnnotationComment],->  annotations_comments :: [(SrcSpan,[Located AnnotationComment])]+>  annotations :: [(ApiAnnKey,[RealSrcSpan])],+>  comment_q :: [RealLocated AnnotationComment],+>  annotations_comments :: [(RealSrcSpan,[RealLocated AnnotationComment])]  The 'annotations' and 'annotations_comments' fields are simple: they simply accumulate annotations that will end up in 'ApiAnns' at the end@@ -105,21 +110,21 @@ The 'comment_q' field captures comments as they are seen in the token stream, so that when they are ready to be allocated via the parser they are available (at the time we lex a comment, we don't know what the enclosing-AST node of it is, so we can't associate it with a SrcSpan in+AST node of it is, so we can't associate it with a RealSrcSpan in annotations_comments).  PARSER EMISSION OF ANNOTATIONS  The parser interacts with the lexer using the function -> addAnnotation :: SrcSpan -> AnnKeywordId -> SrcSpan -> P ()+> addAnnotation :: RealSrcSpan -> AnnKeywordId -> RealSrcSpan -> P () -which takes the AST element SrcSpan, the annotation keyword and the-target SrcSpan.+which takes the AST element RealSrcSpan, the annotation keyword and the+target RealSrcSpan.  This adds the annotation to the `annotations` field of `PState` and transfers any comments in `comment_q` WHICH ARE ENCLOSED by-the SrcSpan of this element to the `annotations_comments`+the RealSrcSpan of this element to the `annotations_comments` field.  (Comments which are outside of this annotation are deferred until later. 'allocateComments' in 'Lexer' is responsible for making sure we only attach comments that actually fit in the 'SrcSpan'.)@@ -131,49 +136,59 @@ -- ---------------------------------------------------------------------  -- If you update this, update the Note [Api annotations] above-type ApiAnns = ( Map.Map ApiAnnKey [SrcSpan]-               , Map.Map SrcSpan [Located AnnotationComment])+data ApiAnns =+  ApiAnns+    { apiAnnItems :: Map.Map ApiAnnKey [RealSrcSpan],+      apiAnnEofPos :: Maybe RealSrcSpan,+      apiAnnComments :: Map.Map RealSrcSpan [RealLocated AnnotationComment],+      apiAnnRogueComments :: [RealLocated AnnotationComment]+    }  -- If you update this, update the Note [Api annotations] above-type ApiAnnKey = (SrcSpan,AnnKeywordId)+type ApiAnnKey = (RealSrcSpan,AnnKeywordId)   -- | Retrieve a list of annotation 'SrcSpan's based on the 'SrcSpan' -- of the annotated AST element, and the known type of the annotation.-getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]-getAnnotation (anns,_) span ann-   = case Map.lookup (span,ann) anns of-       Nothing -> []-       Just ss -> ss+getAnnotation :: ApiAnns -> RealSrcSpan -> AnnKeywordId -> [RealSrcSpan]+getAnnotation anns span ann =+  case Map.lookup ann_key ann_items of+    Nothing -> []+    Just ss -> ss+  where ann_items = apiAnnItems anns+        ann_key = (span,ann)  -- | Retrieve a list of annotation 'SrcSpan's based on the 'SrcSpan' -- of the annotated AST element, and the known type of the annotation. -- The list is removed from the annotations.-getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId-                       -> ([SrcSpan],ApiAnns)-getAndRemoveAnnotation (anns,cs) span ann-   = case Map.lookup (span,ann) anns of-       Nothing -> ([],(anns,cs))-       Just ss -> (ss,(Map.delete (span,ann) anns,cs))+getAndRemoveAnnotation :: ApiAnns -> RealSrcSpan -> AnnKeywordId+                       -> ([RealSrcSpan],ApiAnns)+getAndRemoveAnnotation anns span ann =+  case Map.lookup ann_key ann_items of+    Nothing -> ([],anns)+    Just ss -> (ss,anns{ apiAnnItems = Map.delete ann_key ann_items })+  where ann_items = apiAnnItems anns+        ann_key = (span,ann)  -- |Retrieve the comments allocated to the current 'SrcSpan' -- --  Note: A given 'SrcSpan' may appear in multiple AST elements, --  beware of duplicates-getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]-getAnnotationComments (_,anns) span =-  case Map.lookup span anns of+getAnnotationComments :: ApiAnns -> RealSrcSpan -> [RealLocated AnnotationComment]+getAnnotationComments anns span =+  case Map.lookup span (apiAnnComments anns) of     Just cs -> cs     Nothing -> []  -- |Retrieve the comments allocated to the current 'SrcSpan', and -- remove them from the annotations-getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan-                               -> ([Located AnnotationComment],ApiAnns)-getAndRemoveAnnotationComments (anns,canns) span =-  case Map.lookup span canns of-    Just cs -> (cs,(anns,Map.delete span canns))-    Nothing -> ([],(anns,canns))+getAndRemoveAnnotationComments :: ApiAnns -> RealSrcSpan+                               -> ([RealLocated AnnotationComment],ApiAnns)+getAndRemoveAnnotationComments anns span =+  case Map.lookup span ann_comments of+    Just cs -> (cs, anns{ apiAnnComments = Map.delete span ann_comments })+    Nothing -> ([], anns)+  where ann_comments = apiAnnComments anns  -- -------------------------------------------------------------------- @@ -296,7 +311,6 @@     | AnnLarrowtailU -- ^ '-<<', unicode variant     | AnnRarrowtail -- ^ '>>-'     | AnnRarrowtailU -- ^ '>>-', unicode variant-    | AnnEofPos     deriving (Eq, Ord, Data, Show)  instance Outputable AnnKeywordId where

compiler/parser/RdrHsSyn.hs view

@@ -56,7 +56,7 @@         checkContext,         -- HsType -> P HsContext         checkPattern,         -- HsExp -> P HsPat         checkPattern_msg,-        checkMonadComp,       -- P (HsStmtContext RdrName)+        checkMonadComp,       -- P (HsStmtContext GhcPs)         checkValDef,          -- (SrcLoc, HsExp, HsRhs, [HsDecl]) -> P HsDecl         checkValSigLhs,         LRuleTyTmVar, RuleTyTmVar(..),@@ -111,7 +111,6 @@ import RdrName import Name import BasicTypes-import TcEvidence       ( idHsWrapper ) import Lexer import Lexeme           ( isLexCon ) import Type             ( TyThing(..), funTyCon )@@ -131,7 +130,7 @@ import Util import ApiAnnotation import Data.List-import DynFlags ( WarningFlag(..), DynFlags )+import GHC.Driver.Session ( WarningFlag(..), DynFlags ) import ErrUtils ( Messages )  import Control.Monad@@ -139,6 +138,7 @@ import Data.Char import qualified Data.Monoid as Monoid import Data.Data       ( dataTypeOf, fromConstr, dataTypeConstrs )+import Data.Kind       ( Type )  #include "HsVersions.h" @@ -1194,7 +1194,6 @@   = FunBind { fun_ext = noExtField,               fun_id = fn,               fun_matches = mkMatchGroup FromSource ms,-              fun_co_fn = idHsWrapper,               fun_tick = [] }  -- See Note [FunBind vs PatBind]@@ -1675,7 +1674,7 @@ -- If the flag MonadComprehensions is set, return a 'MonadComp' context, -- otherwise use the usual 'ListComp' context -checkMonadComp :: PV (HsStmtContext Name)+checkMonadComp :: PV (HsStmtContext GhcRn) checkMonadComp = do     monadComprehensions <- getBit MonadComprehensionsBit     return $ if monadComprehensions@@ -1735,7 +1734,7 @@ -- See Note [Ambiguous syntactic categories] class b ~ (Body b) GhcPs => DisambECP b where   -- | See Note [Body in DisambECP]-  type Body b :: * -> *+  type Body b :: Type -> Type   -- | Return a command without ambiguity, or fail in a non-command context.   ecpFromCmd' :: LHsCmd GhcPs -> PV (Located b)   -- | Return an expression without ambiguity, or fail in a non-expression context.@@ -1845,7 +1844,7 @@ {- Note [Body in DisambECP] ~~~~~~~~~~~~~~~~~~~~~~~~~~~ There are helper functions (mkBodyStmt, mkBindStmt, unguardedRHS, etc) that-require their argument to take a form of (body GhcPs) for some (body :: * ->+require their argument to take a form of (body GhcPs) for some (body :: Type -> *). To satisfy this requirement, we say that (b ~ Body b GhcPs) in the superclass constraints of DisambECP. @@ -2275,7 +2274,7 @@     -- ^ If-expression: if p then x else y   | FrameCase LFrame [LFrameMatch]     -- ^ Case-expression: case x of { p1 -> e1; p2 -> e2 }-  | FrameDo (HsStmtContext Name) [LFrameStmt]+  | FrameDo (HsStmtContext GhcRn) [LFrameStmt]     -- ^ Do-expression: do { s1; a <- s2; s3 }   ...   | FrameExpr (HsExpr GhcPs)   -- unambiguously an expression@@ -2852,9 +2851,9 @@ data PV_Accum =   PV_Accum     { pv_messages :: DynFlags -> Messages-    , pv_annotations :: [(ApiAnnKey,[SrcSpan])]-    , pv_comment_q :: [Located AnnotationComment]-    , pv_annotations_comments :: [(SrcSpan,[Located AnnotationComment])]+    , pv_annotations :: [(ApiAnnKey,[RealSrcSpan])]+    , pv_comment_q :: [RealLocated AnnotationComment]+    , pv_annotations_comments :: [(RealSrcSpan,[RealLocated AnnotationComment])]     }  data PV_Result a = PV_Ok PV_Accum a | PV_Failed PV_Accum@@ -2919,7 +2918,7 @@     PV $ \ctx acc ->       let b = ext `xtest` pExtsBitmap (pv_options ctx) in       PV_Ok acc $! b-  addAnnotation l a v =+  addAnnotation (RealSrcSpan l _) a (RealSrcSpan v _) =     PV $ \_ acc ->       let         (comment_q', new_ann_comments) = allocateComments l (pv_comment_q acc)@@ -2931,6 +2930,7 @@           , pv_annotations_comments = annotations_comments' }       in         PV_Ok acc' ()+  addAnnotation _ _ _ = return ()  {- Note [Parser-Validator] ~~~~~~~~~~~~~~~~~~~~~~~~~~

compiler/prelude/PrelNames.hs view

@@ -463,6 +463,12 @@         , typeErrorVAppendDataConName         , typeErrorShowTypeDataConName +        -- Unsafe coercion proofs+        , unsafeEqualityProofName+        , unsafeEqualityTyConName+        , unsafeReflDataConName+        , unsafeCoercePrimName+        , unsafeCoerceName     ]  genericTyConNames :: [Name]@@ -502,7 +508,7 @@     gHC_CLASSES, gHC_PRIMOPWRAPPERS, gHC_BASE, gHC_ENUM,     gHC_GHCI, gHC_GHCI_HELPERS, gHC_CSTRING,     gHC_SHOW, gHC_READ, gHC_NUM, gHC_MAYBE, gHC_INTEGER_TYPE, gHC_NATURAL,-    gHC_LIST, gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING,+    gHC_LIST, gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_LIST, dATA_STRING,     dATA_FOLDABLE, dATA_TRAVERSABLE,     gHC_CONC, gHC_IO, gHC_IO_Exception,     gHC_ST, gHC_IX, gHC_STABLE, gHC_PTR, gHC_ERR, gHC_REAL,@@ -511,7 +517,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, dEBUG_TRACE :: Module+    dATA_COERCE, dEBUG_TRACE, uNSAFE_COERCE :: Module  gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")@@ -534,6 +540,7 @@ gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple") dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple") dATA_EITHER     = mkBaseModule (fsLit "Data.Either")+dATA_LIST       = mkBaseModule (fsLit "Data.List") dATA_STRING     = mkBaseModule (fsLit "Data.String") dATA_FOLDABLE   = mkBaseModule (fsLit "Data.Foldable") dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")@@ -573,6 +580,7 @@ dATA_TYPE_EQUALITY = mkBaseModule (fsLit "Data.Type.Equality") dATA_COERCE     = mkBaseModule (fsLit "Data.Coerce") dEBUG_TRACE     = mkBaseModule (fsLit "Debug.Trace")+uNSAFE_COERCE   = mkBaseModule (fsLit "Unsafe.Coerce")  gHC_SRCLOC :: Module gHC_SRCLOC = mkBaseModule (fsLit "GHC.SrcLoc")@@ -1318,7 +1326,14 @@ typeErrorShowTypeDataConName =   dcQual gHC_TYPELITS (fsLit "ShowType") typeErrorShowTypeDataConKey -+-- Unsafe coercion proofs+unsafeEqualityProofName, unsafeEqualityTyConName, unsafeCoercePrimName,+  unsafeCoerceName, unsafeReflDataConName :: Name+unsafeEqualityProofName = varQual uNSAFE_COERCE (fsLit "unsafeEqualityProof") unsafeEqualityProofIdKey+unsafeEqualityTyConName = tcQual uNSAFE_COERCE (fsLit "UnsafeEquality") unsafeEqualityTyConKey+unsafeReflDataConName   = dcQual uNSAFE_COERCE (fsLit "UnsafeRefl")     unsafeReflDataConKey+unsafeCoercePrimName    = varQual uNSAFE_COERCE (fsLit "unsafeCoerce#") unsafeCoercePrimIdKey+unsafeCoerceName        = varQual uNSAFE_COERCE (fsLit "unsafeCoerce")  unsafeCoerceIdKey  -- Dynamic toDynName :: Name@@ -1490,7 +1505,7 @@  -- plugins pLUGINS :: Module-pLUGINS = mkThisGhcModule (fsLit "Plugins")+pLUGINS = mkThisGhcModule (fsLit "GHC.Driver.Plugins") pluginTyConName :: Name pluginTyConName = tcQual pLUGINS (fsLit "Plugin") pluginTyConKey frontendPluginTyConName :: Name@@ -1890,6 +1905,11 @@ typeSymbolAppendFamNameKey :: Unique typeSymbolAppendFamNameKey = mkPreludeTyConUnique 190 +-- Unsafe equality+unsafeEqualityTyConKey :: Unique+unsafeEqualityTyConKey = mkPreludeTyConUnique 191++ ---------------- Template Haskell ------------------- --      THNames.hs: USES TyConUniques 200-299 -----------------------------------------------------@@ -2059,6 +2079,9 @@ typeLitSymbolDataConKey   = mkPreludeDataConUnique 112 typeLitNatDataConKey      = mkPreludeDataConUnique 113 +-- Unsafe equality+unsafeReflDataConKey :: Unique+unsafeReflDataConKey      = mkPreludeDataConUnique 114  ---------------- Template Haskell ------------------- --      THNames.hs: USES DataUniques 200-250@@ -2110,11 +2133,10 @@ divIntIdKey                   = mkPreludeMiscIdUnique 23 modIntIdKey                   = mkPreludeMiscIdUnique 24 -unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,-    returnIOIdKey, newStablePtrIdKey,+concatIdKey, filterIdKey, zipIdKey,+    bindIOIdKey, returnIOIdKey, newStablePtrIdKey,     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey :: Unique-unsafeCoerceIdKey             = mkPreludeMiscIdUnique 30 concatIdKey                   = mkPreludeMiscIdUnique 31 filterIdKey                   = mkPreludeMiscIdUnique 32 zipIdKey                      = mkPreludeMiscIdUnique 33@@ -2407,6 +2429,12 @@ mkNaturalIdKey          = mkPreludeMiscIdUnique 567 naturalSDataConKey      = mkPreludeMiscIdUnique 568 wordToNaturalIdKey      = mkPreludeMiscIdUnique 569++-- Unsafe coercion proofs+unsafeEqualityProofIdKey, unsafeCoercePrimIdKey, unsafeCoerceIdKey :: Unique+unsafeEqualityProofIdKey = mkPreludeMiscIdUnique 570+unsafeCoercePrimIdKey    = mkPreludeMiscIdUnique 571+unsafeCoerceIdKey        = mkPreludeMiscIdUnique 572  {- ************************************************************************

compiler/prelude/PrelRules.hs view

@@ -14,7 +14,7 @@  {-# LANGUAGE CPP, RankNTypes, PatternSynonyms, ViewPatterns, RecordWildCards,     DeriveFunctor #-}-{-# OPTIONS_GHC -optc-DNON_POSIX_SOURCE #-}+{-# OPTIONS_GHC -optc-DNON_POSIX_SOURCE -Wno-incomplete-uni-patterns #-}  module PrelRules    ( primOpRules@@ -29,20 +29,21 @@  import {-# SOURCE #-} MkId ( mkPrimOpId, magicDictId ) -import CoreSyn-import MkCore+import GHC.Core+import GHC.Core.Make import Id import Literal-import CoreOpt     ( exprIsLiteral_maybe )-import PrimOp      ( PrimOp(..), tagToEnumKey )+import GHC.Core.SimpleOpt ( exprIsLiteral_maybe )+import PrimOp             ( PrimOp(..), tagToEnumKey ) import TysWiredIn import TysPrim import TyCon       ( tyConDataCons_maybe, isAlgTyCon, isEnumerationTyCon                    , isNewTyCon, unwrapNewTyCon_maybe, tyConDataCons                    , tyConFamilySize )-import DataCon     ( dataConTagZ, dataConTyCon, dataConWorkId )-import CoreUtils   ( cheapEqExpr, cheapEqExpr', exprIsHNF, exprType, stripTicksTop, stripTicksTopT, mkTicks )-import CoreUnfold  ( exprIsConApp_maybe )+import DataCon     ( dataConTagZ, dataConTyCon, dataConWrapId, dataConWorkId )+import GHC.Core.Utils  ( cheapEqExpr, cheapEqExpr', exprIsHNF, exprType+                       , stripTicksTop, stripTicksTopT, mkTicks )+import GHC.Core.Unfold ( exprIsConApp_maybe ) import Type import OccName     ( occNameFS ) import PrelNames@@ -51,7 +52,7 @@ import Outputable import FastString import BasicTypes-import DynFlags+import GHC.Driver.Session import GHC.Platform import Util import Coercion     (mkUnbranchedAxInstCo,mkSymCo,Role(..))@@ -739,7 +740,7 @@     in ...  This was originally done in the fix to #16449 but this breaks the let/app-invariant (see Note [CoreSyn let/app invariant] in CoreSyn) as noted in #16742.+invariant (see Note [Core let/app invariant] in GHC.Core) as noted in #16742. For the reasons discussed in Note [Checking versus non-checking primops] (in the PrimOp module) there is no safe way rewrite the argument of I# such that it bottoms.@@ -777,23 +778,26 @@ mkBasicRule :: Name -> Int -> RuleM CoreExpr -> CoreRule -- Gives the Rule the same name as the primop itself mkBasicRule op_name n_args rm-  = BuiltinRule { ru_name = occNameFS (nameOccName op_name),-                  ru_fn = op_name,+  = BuiltinRule { ru_name  = occNameFS (nameOccName op_name),+                  ru_fn    = op_name,                   ru_nargs = n_args,-                  ru_try = \ dflags in_scope _ -> runRuleM rm dflags in_scope }+                  ru_try   = runRuleM rm }  newtype RuleM r = RuleM-  { runRuleM :: DynFlags -> InScopeEnv -> [CoreExpr] -> Maybe r }+  { runRuleM :: DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe r }   deriving (Functor)  instance Applicative RuleM where-    pure x = RuleM $ \_ _ _ -> Just x+    pure x = RuleM $ \_ _ _ _ -> Just x     (<*>) = ap  instance Monad RuleM where-  RuleM f >>= g = RuleM $ \dflags iu e -> case f dflags iu e of-    Nothing -> Nothing-    Just r -> runRuleM (g r) dflags iu e+  RuleM f >>= g+    = RuleM $ \dflags iu fn args ->+              case f dflags iu fn args of+                Nothing -> Nothing+                Just r  -> runRuleM (g r) dflags iu fn args+ #if !MIN_VERSION_base(4,13,0)   fail = MonadFail.fail #endif@@ -802,14 +806,14 @@     fail _ = mzero  instance Alternative RuleM where-  empty = RuleM $ \_ _ _ -> Nothing-  RuleM f1 <|> RuleM f2 = RuleM $ \dflags iu args ->-    f1 dflags iu args <|> f2 dflags iu args+  empty = RuleM $ \_ _ _ _ -> Nothing+  RuleM f1 <|> RuleM f2 = RuleM $ \dflags iu fn args ->+    f1 dflags iu fn args <|> f2 dflags iu fn args  instance MonadPlus RuleM  instance HasDynFlags RuleM where-    getDynFlags = RuleM $ \dflags _ _ -> Just dflags+    getDynFlags = RuleM $ \dflags _ _ _ -> Just dflags  liftMaybe :: Maybe a -> RuleM a liftMaybe Nothing = mzero@@ -835,15 +839,18 @@       mzero  getArgs :: RuleM [CoreExpr]-getArgs = RuleM $ \_ _ args -> Just args+getArgs = RuleM $ \_ _ _ args -> Just args  getInScopeEnv :: RuleM InScopeEnv-getInScopeEnv = RuleM $ \_ iu _ -> Just iu+getInScopeEnv = RuleM $ \_ iu _ _ -> Just iu +getFunction :: RuleM Id+getFunction = RuleM $ \_ _ fn _ -> Just fn+ -- return the n-th argument of this rule, if it is a literal -- argument indices start from 0 getLiteral :: Int -> RuleM Literal-getLiteral n = RuleM $ \_ _ exprs -> case drop n exprs of+getLiteral n = RuleM $ \_ _ _ exprs -> case drop n exprs of   (Lit l:_) -> Just l   _ -> Nothing @@ -1097,12 +1104,12 @@ as fancy as argument evaluation.)  The special handling for dataToTag# is: -* CoreUtils.exprOkForSpeculation has a special case for DataToTagOp,+* GHC.Core.Utils.exprOkForSpeculation has a special case for DataToTagOp,   (actually in app_ok).  Most primops with lifted arguments do not   evaluate those arguments, but DataToTagOp and SeqOp are two   exceptions.  We say that they are /never/ ok-for-speculation,   regardless of the evaluated-ness of their argument.-  See CoreUtils Note [exprOkForSpeculation and SeqOp/DataToTagOp]+  See GHC.Core.Utils Note [exprOkForSpeculation and SeqOp/DataToTagOp]  * There is a special case for DataToTagOp in GHC.StgToCmm.Expr.cgExpr,   that evaluates its argument and then extracts the tag from@@ -1118,14 +1125,35 @@   by PrelRules.caseRules; see Note [caseRules for dataToTag]  See #15696 for a long saga.+-} +{- *********************************************************************+*                                                                      *+             unsafeEqualityProof+*                                                                      *+********************************************************************* -} -************************************************************************+-- unsafeEqualityProof k t t  ==>  UnsafeRefl (Refl t)+-- That is, if the two types are equal, it's not unsafe!++unsafeEqualityProofRule :: RuleM CoreExpr+unsafeEqualityProofRule+  = do { [Type rep, Type t1, Type t2] <- getArgs+       ; guard (t1 `eqType` t2)+       ; fn <- getFunction+       ; let (_, ue) = splitForAllTys (idType fn)+             tc      = tyConAppTyCon ue  -- tycon:    UnsafeEquality+             (dc:_)  = tyConDataCons tc  -- data con: UnsafeRefl+             -- UnsafeRefl :: forall (r :: RuntimeRep) (a :: TYPE r).+             --               UnsafeEquality r a a+       ; return (mkTyApps (Var (dataConWrapId dc)) [rep, t1]) }+++{- ********************************************************************* *                                                                      *-\subsection{Rules for seq# and spark#}+             Rules for seq# and spark# *                                                                      *-************************************************************************--}+********************************************************************* -}  {- Note [seq# magic] ~~~~~~~~~~~~~~~~~~~~@@ -1173,8 +1201,8 @@  - GHC.StgToCmm.Expr.cgExpr, and cgCase: special case for seq# -- CoreUtils.exprOkForSpeculation;-  see Note [exprOkForSpeculation and SeqOp/DataToTagOp] in CoreUtils+- GHC.Core.Utils.exprOkForSpeculation;+  see Note [exprOkForSpeculation and SeqOp/DataToTagOp] in GHC.Core.Utils  - Simplify.addEvals records evaluated-ness for the result; see   Note [Adding evaluatedness info to pattern-bound variables]@@ -1218,13 +1246,11 @@         ....and lower down...         eqString = ... -and lo, eqString is not in scope.  This only really matters when we get to code-generation.  With -O we do a GlomBinds step that does a new SCC analysis on the whole-set of bindings, which sorts out the dependency.  Without -O we don't do any rule-rewriting so again we are fine.--(This whole thing doesn't show up for non-built-in rules because their dependencies-are explicit.)+and lo, eqString is not in scope.  This only really matters when we+get to code generation.  But the occurrence analyser does a GlomBinds+step when necessary, that does a new SCC analysis on the whole set of+bindings (see occurAnalysePgm), which sorts out the dependency, so all+is fine. -}  builtinRules :: [CoreRule]@@ -1239,6 +1265,9 @@                    ru_nargs = 2, ru_try = \_ _ _ -> match_inline },      BuiltinRule { ru_name = fsLit "MagicDict", ru_fn = idName magicDictId,                    ru_nargs = 4, ru_try = \_ _ _ -> match_magicDict },++     mkBasicRule unsafeEqualityProofName 3 unsafeEqualityProofRule,+      mkBasicRule divIntName 2 $ msum         [ nonZeroLit 1 >> binaryLit (intOp2 div)         , leftZero zeroi@@ -1248,6 +1277,7 @@           dflags <- getDynFlags           return $ Var (mkPrimOpId ISraOp) `App` arg `App` mkIntVal dflags n         ],+      mkBasicRule modIntName 2 $ msum         [ nonZeroLit 1 >> binaryLit (intOp2 mod)         , leftZero zeroi

compiler/prelude/PrimOp.hs view

@@ -323,7 +323,7 @@    It is important that a non-checking primop never be transformed in a way that   would cause it to bottom. Doing so would violate Core's let/app invariant-  (see Note [CoreSyn let/app invariant] in CoreSyn) which is critical to+  (see Note [Core let/app invariant] in GHC.Core) which is critical to   the simplifier's ability to float without fear of changing program meaning.  @@ -483,7 +483,7 @@  primOpOkForSpeculation :: PrimOp -> Bool   -- See Note [PrimOp can_fail and has_side_effects]-  -- See comments with CoreUtils.exprOkForSpeculation+  -- See comments with GHC.Core.Utils.exprOkForSpeculation   -- primOpOkForSpeculation => primOpOkForSideEffects primOpOkForSpeculation op   =  primOpOkForSideEffects op@@ -535,7 +535,7 @@ primOpCodeSize ~~~~~~~~~~~~~~ Gives an indication of the code size of a primop, for the purposes of-calculating unfolding sizes; see CoreUnfold.sizeExpr.+calculating unfolding sizes; see GHC.Core.Unfold.sizeExpr. -}  primOpCodeSize :: PrimOp -> Int@@ -543,7 +543,7 @@  primOpCodeSizeDefault :: Int primOpCodeSizeDefault = 1-  -- CoreUnfold.primOpSize already takes into account primOpOutOfLine+  -- GHC.Core.Unfold.primOpSize already takes into account primOpOutOfLine   -- and adds some further costs for the args in that case.  primOpCodeSizeForeignCall :: Int

compiler/prelude/TysPrim.hs view

@@ -376,6 +376,8 @@ runtimeRep2Ty = mkTyVarTy runtimeRep2TyVar  openAlphaTyVar, openBetaTyVar :: TyVar+-- alpha :: TYPE r1+-- beta  :: TYPE r2 [openAlphaTyVar,openBetaTyVar]   = mkTemplateTyVars [tYPE runtimeRep1Ty, tYPE runtimeRep2Ty] @@ -459,7 +461,7 @@ * error :: forall (rr:RuntimeRep) (a:TYPE rr). String -> a   Code generator never has to manipulate the return value. -* unsafeCoerce#, defined in MkId.unsafeCoerceId:+* unsafeCoerce#, defined in Desugar.mkUnsafeCoercePair:   Always inlined to be a no-op      unsafeCoerce# :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)                              (a :: TYPE r1) (b :: TYPE r2).@@ -509,7 +511,7 @@ -- ... and now their names  -- If you edit these, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs+-- See Note [GHC Formalism] in GHC.Core.Lint tYPETyConName             = mkPrimTyConName (fsLit "TYPE") tYPETyConKey tYPETyCon  mkPrimTyConName :: FastString -> Unique -> TyCon -> Name

compiler/prelude/TysWiredIn.hs view

@@ -126,7 +126,6 @@         int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,         word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,         doubleElemRepDataConTy-     ) where  #include "HsVersions.h"@@ -155,8 +154,7 @@ import Name import NameEnv          ( NameEnv, mkNameEnv, lookupNameEnv, lookupNameEnv_NF ) import NameSet          ( NameSet, mkNameSet, elemNameSet )-import BasicTypes       ( Arity, Boxity(..), TupleSort(..), ConTagZ,-                          SourceText(..) )+import BasicTypes import ForeignCall import SrcLoc           ( noSrcSpan ) import Unique@@ -565,6 +563,13 @@                      -> [Type] -> TyCon -> DataCon -- The Name should be in the DataName name space; it's the name -- of the DataCon itself.+--+-- IMPORTANT NOTE:+--    if you try to wire-in a /GADT/ data constructor you will+--    find it hard (we did).  You will need wrapper and worker+--    Names, a DataConBoxer, DataConRep, EqSpec, etc.+--    Try hard not to wire-in GADT data types. You will live+--    to regret doing so (we do).  pcDataConWithFixity' declared_infix dc_name wrk_key rri                      tyvars ex_tyvars user_tyvars arg_tys tycon@@ -702,7 +707,7 @@ GHC supports both boxed and unboxed one-tuples:  - Unboxed one-tuples are sometimes useful when returning a    single value after CPR analysis- - A boxed one-tuple is used by DsUtils.mkSelectorBinds, when+ - A boxed one-tuple is used by GHC.HsToCore.Utils.mkSelectorBinds, when    there is just one binder Basically it keeps everything uniform. @@ -728,8 +733,8 @@ tuples. See [Ignore unary constraint tuples] in TcHsType for more details. -See also Note [Flattening one-tuples] in MkCore and-Note [Don't flatten tuples from HsSyn] in MkCore.+See also Note [Flattening one-tuples] in GHC.Core.Make and+Note [Don't flatten tuples from HsSyn] in GHC.Core.Make.  -} @@ -1513,12 +1518,7 @@ mkListTy ty = mkTyConApp listTyCon [ty]  listTyCon :: TyCon-listTyCon =-  buildAlgTyCon listTyConName alpha_tyvar [Representational]-                Nothing []-                (mkDataTyConRhs [nilDataCon, consDataCon])-                False-                (VanillaAlgTyCon $ mkPrelTyConRepName listTyConName)+listTyCon = pcTyCon listTyConName Nothing [alphaTyVar] [nilDataCon, consDataCon]  -- See also Note [Empty lists] in GHC.Hs.Expr. nilDataCon :: DataCon@@ -1604,7 +1604,7 @@ -- | Make a tuple type. The list of types should /not/ include any -- RuntimeRep specifications. Boxed 1-tuples are *not* flattened. -- See Note [One-tuples] and Note [Don't flatten tuples from HsSyn]--- in MkCore+-- in GHC.Core.Make mkTupleTy1 :: Boxity -> [Type] -> Type mkTupleTy1 Boxed   tys  = mkTyConApp (tupleTyCon Boxed (length tys)) tys mkTupleTy1 Unboxed tys  = mkTyConApp (tupleTyCon Unboxed (length tys))

compiler/prelude/TysWiredIn.hs-boot view

@@ -15,6 +15,8 @@ unitTy :: Type  liftedTypeKind :: Kind+liftedTypeKindTyCon :: TyCon+ constraintKind :: Kind  runtimeRepTyCon, vecCountTyCon, vecElemTyCon :: TyCon

compiler/simplCore/CoreMonad.hs view

@@ -51,10 +51,10 @@  import GhcPrelude hiding ( read ) -import CoreSyn-import HscTypes+import GHC.Core+import GHC.Driver.Types import Module-import DynFlags+import GHC.Driver.Session import BasicTypes       ( CompilerPhase(..) ) import Annotations @@ -71,7 +71,7 @@ import SrcLoc import Data.Bifunctor ( bimap ) import ErrUtils (dumpAction)-import Data.List+import Data.List (intersperse, groupBy, sortBy) import Data.Ord import Data.Dynamic import Data.IORef@@ -107,7 +107,8 @@   | CoreDoStaticArgs   | CoreDoCallArity   | CoreDoExitify-  | CoreDoStrictness+  | CoreDoDemand+  | CoreDoCpr   | CoreDoWorkerWrapper   | CoreDoSpecialising   | CoreDoSpecConstr@@ -134,7 +135,8 @@   ppr CoreDoStaticArgs         = text "Static argument"   ppr CoreDoCallArity          = text "Called arity analysis"   ppr CoreDoExitify            = text "Exitification transformation"-  ppr CoreDoStrictness         = text "Demand analysis"+  ppr CoreDoDemand             = text "Demand analysis"+  ppr CoreDoCpr                = text "Constructed Product Result analysis"   ppr CoreDoWorkerWrapper      = text "Worker Wrapper binds"   ppr CoreDoSpecialising       = text "Specialise"   ppr CoreDoSpecConstr         = text "SpecConstr"

compiler/simplCore/OccurAnal.hs view

@@ -23,11 +23,11 @@  import GhcPrelude -import CoreSyn-import CoreFVs-import CoreUtils        ( exprIsTrivial, isDefaultAlt, isExpandableApp,+import GHC.Core+import GHC.Core.FVs+import GHC.Core.Utils   ( exprIsTrivial, isDefaultAlt, isExpandableApp,                           stripTicksTopE, mkTicks )-import CoreArity        ( joinRhsArity )+import GHC.Core.Arity   ( joinRhsArity ) import Id import IdInfo import Name( localiseName )@@ -81,11 +81,16 @@     (final_usage, occ_anald_binds) = go init_env binds     (_, occ_anald_glommed_binds)   = occAnalRecBind init_env TopLevel                                                     imp_rule_edges-                                                    (flattenBinds occ_anald_binds)+                                                    (flattenBinds binds)                                                     initial_uds           -- It's crucial to re-analyse the glommed-together bindings           -- so that we establish the right loop breakers. Otherwise           -- we can easily create an infinite loop (#9583 is an example)+          --+          -- Also crucial to re-analyse the /original/ bindings+          -- in case the first pass accidentally discarded as dead code+          -- a binding that was actually needed (albeit before its+          -- definition site).  #17724 threw this up.      initial_uds = addManyOccsSet emptyDetails                             (rulesFreeVars imp_rules)@@ -2757,7 +2762,7 @@ -- the decision about another binding 'g' might be invalidated if (say) -- 'f' tail-calls 'g'. ----- See Note [Invariants on join points] in CoreSyn.+-- See Note [Invariants on join points] in GHC.Core. decideJoinPointHood :: TopLevelFlag -> UsageDetails                     -> [CoreBndr]                     -> Bool@@ -2830,7 +2835,7 @@ 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.  #13413.+GHC.Core.  #13413.  Moreover, since g is going to be inlined anyway, there is no benefit from making it a join point.@@ -2842,7 +2847,7 @@ unravels; so ignoring INLINE pragmas on recursive things isn't good either. -See Invariant 2a of Note [Invariants on join points] in CoreSyn+See Invariant 2a of Note [Invariants on join points] in GHC.Core   ************************************************************************

− compiler/specialise/Rules.hs

@@ -1,1254 +0,0 @@-{--(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[CoreRules]{Transformation rules}--}--{-# LANGUAGE CPP #-}---- | Functions for collecting together and applying rewrite rules to a module.--- The 'CoreRule' datatype itself is declared elsewhere.-module Rules (-        -- ** Constructing-        emptyRuleBase, mkRuleBase, extendRuleBaseList,-        unionRuleBase, pprRuleBase,--        -- ** Checking rule applications-        ruleCheckProgram,--        -- ** Manipulating 'RuleInfo' rules-        mkRuleInfo, extendRuleInfo, addRuleInfo,-        addIdSpecialisations,--        -- * Misc. CoreRule helpers-        rulesOfBinds, getRules, pprRulesForUser,--        lookupRule, mkRule, roughTopNames-    ) where--#include "HsVersions.h"--import GhcPrelude--import CoreSyn          -- All of it-import Module           ( Module, ModuleSet, elemModuleSet )-import CoreSubst-import CoreOpt          ( exprIsLambda_maybe )-import CoreFVs          ( exprFreeVars, exprsFreeVars, bindFreeVars-                        , rulesFreeVarsDSet, exprsOrphNames, exprFreeVarsList )-import CoreUtils        ( exprType, eqExpr, mkTick, mkTicks,-                          stripTicksTopT, stripTicksTopE,-                          isJoinBind )-import PprCore          ( pprRules )-import Type             ( Type, TCvSubst, extendTvSubst, extendCvSubst-                        , mkEmptyTCvSubst, substTy )-import TcType           ( tcSplitTyConApp_maybe )-import TysWiredIn       ( anyTypeOfKind )-import Coercion-import CoreTidy         ( tidyRules )-import Id-import IdInfo           ( RuleInfo( RuleInfo ) )-import Var-import VarEnv-import VarSet-import Name             ( Name, NamedThing(..), nameIsLocalOrFrom )-import NameSet-import NameEnv-import UniqFM-import Unify            ( ruleMatchTyKiX )-import BasicTypes-import DynFlags         ( DynFlags )-import Outputable-import FastString-import Maybes-import Bag-import Util-import Data.List-import Data.Ord-import Control.Monad    ( guard )--{--Note [Overall plumbing for rules]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-* After the desugarer:-   - The ModGuts initially contains mg_rules :: [CoreRule] of-     locally-declared rules for imported Ids.-   - Locally-declared rules for locally-declared Ids are attached to-     the IdInfo for that Id.  See Note [Attach rules to local ids] in-     DsBinds--* GHC.Iface.Tidy strips off all the rules from local Ids and adds them to-  mg_rules, so that the ModGuts has *all* the locally-declared rules.--* The HomePackageTable contains a ModDetails for each home package-  module.  Each contains md_rules :: [CoreRule] of rules declared in-  that module.  The HomePackageTable grows as ghc --make does its-  up-sweep.  In batch mode (ghc -c), the HPT is empty; all imported modules-  are treated by the "external" route, discussed next, regardless of-  which package they come from.--* The ExternalPackageState has a single eps_rule_base :: RuleBase for-  Ids in other packages.  This RuleBase simply grow monotonically, as-  ghc --make compiles one module after another.--  During simplification, interface files may get demand-loaded,-  as the simplifier explores the unfoldings for Ids it has in-  its hand.  (Via an unsafePerformIO; the EPS is really a cache.)-  That in turn may make the EPS rule-base grow.  In contrast, the-  HPT never grows in this way.--* The result of all this is that during Core-to-Core optimisation-  there are four sources of rules:--    (a) Rules in the IdInfo of the Id they are a rule for.  These are-        easy: fast to look up, and if you apply a substitution then-        it'll be applied to the IdInfo as a matter of course.--    (b) Rules declared in this module for imported Ids, kept in the-        ModGuts. If you do a substitution, you'd better apply the-        substitution to these.  There are seldom many of these.--    (c) Rules declared in the HomePackageTable.  These never change.--    (d) Rules in the ExternalPackageTable. These can grow in response-        to lazy demand-loading of interfaces.--* At the moment (c) is carried in a reader-monad way by the CoreMonad.-  The HomePackageTable doesn't have a single RuleBase because technically-  we should only be able to "see" rules "below" this module; so we-  generate a RuleBase for (c) by combing rules from all the modules-  "below" us.  That's why we can't just select the home-package RuleBase-  from HscEnv.--  [NB: we are inconsistent here.  We should do the same for external-  packages, but we don't.  Same for type-class instances.]--* So in the outer simplifier loop, we combine (b-d) into a single-  RuleBase, reading-     (b) from the ModGuts,-     (c) from the CoreMonad, and-     (d) from its mutable variable-  [Of course this means that we won't see new EPS rules that come in-  during a single simplifier iteration, but that probably does not-  matter.]---************************************************************************-*                                                                      *-\subsection[specialisation-IdInfo]{Specialisation info about an @Id@}-*                                                                      *-************************************************************************--A @CoreRule@ holds details of one rule for an @Id@, which-includes its specialisations.--For example, if a rule for @f@ contains the mapping:-\begin{verbatim}-        forall a b d. [Type (List a), Type b, Var d]  ===>  f' a b-\end{verbatim}-then when we find an application of f to matching types, we simply replace-it by the matching RHS:-\begin{verbatim}-        f (List Int) Bool dict ===>  f' Int Bool-\end{verbatim}-All the stuff about how many dictionaries to discard, and what types-to apply the specialised function to, are handled by the fact that the-Rule contains a template for the result of the specialisation.--There is one more exciting case, which is dealt with in exactly the same-way.  If the specialised value is unboxed then it is lifted at its-definition site and unlifted at its uses.  For example:--        pi :: forall a. Num a => a--might have a specialisation--        [Int#] ===>  (case pi' of Lift pi# -> pi#)--where pi' :: Lift Int# is the specialised version of pi.--}--mkRule :: Module -> Bool -> Bool -> RuleName -> Activation-       -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule--- ^ Used to make 'CoreRule' for an 'Id' defined in the module being--- compiled. See also 'CoreSyn.CoreRule'-mkRule this_mod is_auto is_local name act fn bndrs args rhs-  = Rule { ru_name = name, ru_fn = fn, ru_act = act,-           ru_bndrs = bndrs, ru_args = args,-           ru_rhs = rhs,-           ru_rough = roughTopNames args,-           ru_origin = this_mod,-           ru_orphan = orph,-           ru_auto = is_auto, ru_local = is_local }-  where-        -- Compute orphanhood.  See Note [Orphans] in InstEnv-        -- A rule is an orphan only if none of the variables-        -- mentioned on its left-hand side are locally defined-    lhs_names = extendNameSet (exprsOrphNames args) fn--        -- Since rules get eventually attached to one of the free names-        -- from the definition when compiling the ABI hash, we should make-        -- it deterministic. This chooses the one with minimal OccName-        -- as opposed to uniq value.-    local_lhs_names = filterNameSet (nameIsLocalOrFrom this_mod) lhs_names-    orph = chooseOrphanAnchor local_lhs_names-----------------roughTopNames :: [CoreExpr] -> [Maybe Name]--- ^ Find the \"top\" free names of several expressions.--- Such names are either:------ 1. The function finally being applied to in an application chain---    (if that name is a GlobalId: see "Var#globalvslocal"), or------ 2. The 'TyCon' if the expression is a 'Type'------ This is used for the fast-match-check for rules;---      if the top names don't match, the rest can't-roughTopNames args = map roughTopName args--roughTopName :: CoreExpr -> Maybe Name-roughTopName (Type ty) = case tcSplitTyConApp_maybe ty of-                               Just (tc,_) -> Just (getName tc)-                               Nothing     -> Nothing-roughTopName (Coercion _) = Nothing-roughTopName (App f _) = roughTopName f-roughTopName (Var f)   | isGlobalId f   -- Note [Care with roughTopName]-                       , isDataConWorkId f || idArity f > 0-                       = Just (idName f)-roughTopName (Tick t e) | tickishFloatable t-                        = roughTopName e-roughTopName _ = Nothing--ruleCantMatch :: [Maybe Name] -> [Maybe Name] -> Bool--- ^ @ruleCantMatch tpl actual@ returns True only if @actual@--- definitely can't match @tpl@ by instantiating @tpl@.--- It's only a one-way match; unlike instance matching we--- don't consider unification.------ Notice that [_$_]---      @ruleCantMatch [Nothing] [Just n2] = False@---      Reason: a template variable can be instantiated by a constant--- Also:---      @ruleCantMatch [Just n1] [Nothing] = False@---      Reason: a local variable @v@ in the actuals might [_$_]--ruleCantMatch (Just n1 : ts) (Just n2 : as) = n1 /= n2 || ruleCantMatch ts as-ruleCantMatch (_       : ts) (_       : as) = ruleCantMatch ts as-ruleCantMatch _              _              = False--{--Note [Care with roughTopName]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this-    module M where { x = a:b }-    module N where { ...f x...-                     RULE f (p:q) = ... }-You'd expect the rule to match, because the matcher can-look through the unfolding of 'x'.  So we must avoid roughTopName-returning 'M.x' for the call (f x), or else it'll say "can't match"-and we won't even try!!--However, suppose we have-         RULE g (M.h x) = ...-         foo = ...(g (M.k v))....-where k is a *function* exported by M.  We never really match-functions (lambdas) except by name, so in this case it seems like-a good idea to treat 'M.k' as a roughTopName of the call.--}--pprRulesForUser :: DynFlags -> [CoreRule] -> SDoc--- (a) tidy the rules--- (b) sort them into order based on the rule name--- (c) suppress uniques (unless -dppr-debug is on)--- This combination makes the output stable so we can use in testing--- It's here rather than in PprCore because it calls tidyRules-pprRulesForUser dflags rules-  = withPprStyle (defaultUserStyle dflags) $-    pprRules $-    sortBy (comparing ruleName) $-    tidyRules emptyTidyEnv rules--{--************************************************************************-*                                                                      *-                RuleInfo: the rules in an IdInfo-*                                                                      *-************************************************************************--}---- | Make a 'RuleInfo' containing a number of 'CoreRule's, suitable--- for putting into an 'IdInfo'-mkRuleInfo :: [CoreRule] -> RuleInfo-mkRuleInfo rules = RuleInfo rules (rulesFreeVarsDSet rules)--extendRuleInfo :: RuleInfo -> [CoreRule] -> RuleInfo-extendRuleInfo (RuleInfo rs1 fvs1) rs2-  = RuleInfo (rs2 ++ rs1) (rulesFreeVarsDSet rs2 `unionDVarSet` fvs1)--addRuleInfo :: RuleInfo -> RuleInfo -> RuleInfo-addRuleInfo (RuleInfo rs1 fvs1) (RuleInfo rs2 fvs2)-  = RuleInfo (rs1 ++ rs2) (fvs1 `unionDVarSet` fvs2)--addIdSpecialisations :: Id -> [CoreRule] -> Id-addIdSpecialisations id rules-  | null rules-  = id-  | otherwise-  = setIdSpecialisation id $-    extendRuleInfo (idSpecialisation id) rules---- | Gather all the rules for locally bound identifiers from the supplied bindings-rulesOfBinds :: [CoreBind] -> [CoreRule]-rulesOfBinds binds = concatMap (concatMap idCoreRules . bindersOf) binds--getRules :: RuleEnv -> Id -> [CoreRule]--- See Note [Where rules are found]-getRules (RuleEnv { re_base = rule_base, re_visible_orphs = orphs }) fn-  = idCoreRules fn ++ filter (ruleIsVisible orphs) imp_rules-  where-    imp_rules = lookupNameEnv rule_base (idName fn) `orElse` []--ruleIsVisible :: ModuleSet -> CoreRule -> Bool-ruleIsVisible _ BuiltinRule{} = True-ruleIsVisible vis_orphs Rule { ru_orphan = orph, ru_origin = origin }-    = notOrphan orph || origin `elemModuleSet` vis_orphs--{- Note [Where rules are found]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The rules for an Id come from two places:-  (a) the ones it is born with, stored inside the Id itself (idCoreRules fn),-  (b) rules added in other modules, stored in the global RuleBase (imp_rules)--It's tempting to think that-     - LocalIds have only (a)-     - non-LocalIds have only (b)--but that isn't quite right:--     - PrimOps and ClassOps are born with a bunch of rules inside the Id,-       even when they are imported--     - The rules in PrelRules.builtinRules should be active even-       in the module defining the Id (when it's a LocalId), but-       the rules are kept in the global RuleBase---************************************************************************-*                                                                      *-                RuleBase-*                                                                      *-************************************************************************--}---- RuleBase itself is defined in CoreSyn, along with CoreRule--emptyRuleBase :: RuleBase-emptyRuleBase = emptyNameEnv--mkRuleBase :: [CoreRule] -> RuleBase-mkRuleBase rules = extendRuleBaseList emptyRuleBase rules--extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase-extendRuleBaseList rule_base new_guys-  = foldl' extendRuleBase rule_base new_guys--unionRuleBase :: RuleBase -> RuleBase -> RuleBase-unionRuleBase rb1 rb2 = plusNameEnv_C (++) rb1 rb2--extendRuleBase :: RuleBase -> CoreRule -> RuleBase-extendRuleBase rule_base rule-  = extendNameEnv_Acc (:) singleton rule_base (ruleIdName rule) rule--pprRuleBase :: RuleBase -> SDoc-pprRuleBase rules = pprUFM rules $ \rss ->-  vcat [ pprRules (tidyRules emptyTidyEnv rs)-       | rs <- rss ]--{--************************************************************************-*                                                                      *-                        Matching-*                                                                      *-************************************************************************--}---- | The main rule matching function. Attempts to apply all (active)--- supplied rules to this instance of an application in a given--- context, returning the rule applied and the resulting expression if--- successful.-lookupRule :: DynFlags -> InScopeEnv-           -> (Activation -> Bool)      -- When rule is active-           -> Id -> [CoreExpr]-           -> [CoreRule] -> Maybe (CoreRule, CoreExpr)---- See Note [Extra args in rule matching]--- See comments on matchRule-lookupRule dflags in_scope is_active fn args rules-  = -- pprTrace "matchRules" (ppr fn <+> ppr args $$ ppr rules ) $-    case go [] rules of-        []     -> Nothing-        (m:ms) -> Just (findBest (fn,args') m ms)-  where-    rough_args = map roughTopName args--    -- Strip ticks from arguments, see note [Tick annotations in RULE-    -- matching]. We only collect ticks if a rule actually matches --    -- this matters for performance tests.-    args' = map (stripTicksTopE tickishFloatable) args-    ticks = concatMap (stripTicksTopT tickishFloatable) args--    go :: [(CoreRule,CoreExpr)] -> [CoreRule] -> [(CoreRule,CoreExpr)]-    go ms [] = ms-    go ms (r:rs)-      | Just e <- matchRule dflags in_scope is_active fn args' rough_args r-      = go ((r,mkTicks ticks e):ms) rs-      | otherwise-      = -- pprTrace "match failed" (ppr r $$ ppr args $$-        --   ppr [ (arg_id, unfoldingTemplate unf)-        --       | Var arg_id <- args-        --       , let unf = idUnfolding arg_id-        --       , isCheapUnfolding unf] )-        go ms rs--findBest :: (Id, [CoreExpr])-         -> (CoreRule,CoreExpr) -> [(CoreRule,CoreExpr)] -> (CoreRule,CoreExpr)--- All these pairs matched the expression--- Return the pair the most specific rule--- The (fn,args) is just for overlap reporting--findBest _      (rule,ans)   [] = (rule,ans)-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-                      = ifPprDebug (ppr rule)-                                   (doubleQuotes (ftext (ruleName rule)))-                in pprTrace "Rules.findBest: rule overlap (Rule 1 wins)"-                         (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-  | otherwise = findBest target (rule1,ans1) prs-  where-    (fn,args) = target--isMoreSpecific :: CoreRule -> CoreRule -> Bool--- This tests if one rule is more specific than another--- We take the view that a BuiltinRule is less specific than--- anything else, because we want user-define rules to "win"--- In particular, class ops have a built-in rule, but we--- any user-specific rules to win---   eg (#4397)---      truncate :: (RealFrac a, Integral b) => a -> b---      {-# RULES "truncate/Double->Int" truncate = double2Int #-}---      double2Int :: Double -> Int---   We want the specific RULE to beat the built-in class-op rule-isMoreSpecific (BuiltinRule {}) _                = False-isMoreSpecific (Rule {})        (BuiltinRule {}) = True-isMoreSpecific (Rule { ru_bndrs = bndrs1, ru_args = args1 })-               (Rule { ru_bndrs = bndrs2, ru_args = args2-                     , ru_name = rule_name2, ru_rhs = rhs })-  = isJust (matchN (in_scope, id_unfolding_fun) rule_name2 bndrs2 args2 args1 rhs)-  where-   id_unfolding_fun _ = NoUnfolding     -- Don't expand in templates-   in_scope = mkInScopeSet (mkVarSet bndrs1)-        -- Actually we should probably include the free vars-        -- of rule1's args, but I can't be bothered--noBlackList :: Activation -> Bool-noBlackList _ = False           -- Nothing is black listed--{--Note [Extra args in rule matching]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we find a matching rule, we return (Just (rule, rhs)),-but the rule firing has only consumed as many of the input args-as the ruleArity says.  It's up to the caller to keep track-of any left-over args.  E.g. if you call-        lookupRule ... f [e1, e2, e3]-and it returns Just (r, rhs), where r has ruleArity 2-then the real rewrite is-        f e1 e2 e3 ==> rhs e3--You might think it'd be cleaner for lookupRule to deal with the-leftover arguments, by applying 'rhs' to them, but the main call-in the Simplifier works better as it is.  Reason: the 'args' passed-to lookupRule are the result of a lazy substitution--}---------------------------------------matchRule :: DynFlags -> InScopeEnv -> (Activation -> Bool)-          -> Id -> [CoreExpr] -> [Maybe Name]-          -> CoreRule -> Maybe CoreExpr---- If (matchRule rule args) returns Just (name,rhs)--- then (f args) matches the rule, and the corresponding--- rewritten RHS is rhs------ The returned expression is occurrence-analysed------      Example------ The rule---      forall f g x. map f (map g x) ==> map (f . g) x--- is stored---      CoreRule "map/map"---               [f,g,x]                -- tpl_vars---               [f,map g x]            -- tpl_args---               map (f.g) x)           -- rhs------ Then the call: matchRule the_rule [e1,map e2 e3]---        = Just ("map/map", (\f,g,x -> rhs) e1 e2 e3)------ Any 'surplus' arguments in the input are simply put on the end--- of the output.--matchRule dflags rule_env _is_active fn args _rough_args-          (BuiltinRule { ru_try = match_fn })--- Built-in rules can't be switched off, it seems-  = case match_fn dflags rule_env fn args of-        Nothing   -> Nothing-        Just expr -> Just expr--matchRule _ in_scope is_active _ args rough_args-          (Rule { ru_name = rule_name, ru_act = act, ru_rough = tpl_tops-                , ru_bndrs = tpl_vars, ru_args = tpl_args, ru_rhs = rhs })-  | not (is_active act)               = Nothing-  | ruleCantMatch tpl_tops rough_args = Nothing-  | otherwise = matchN in_scope rule_name tpl_vars tpl_args args rhs------------------------------------------matchN  :: InScopeEnv-        -> RuleName -> [Var] -> [CoreExpr]-        -> [CoreExpr] -> CoreExpr           -- ^ Target; can have more elements than the template-        -> Maybe CoreExpr--- For a given match template and context, find bindings to wrap around--- the entire result and what should be substituted for each template variable.--- Fail if there are two few actual arguments from the target to match the template--matchN (in_scope, id_unf) rule_name tmpl_vars tmpl_es target_es rhs-  = do  { rule_subst <- go init_menv emptyRuleSubst tmpl_es target_es-        ; let (_, matched_es) = mapAccumL (lookup_tmpl rule_subst)-                                          (mkEmptyTCvSubst in_scope) $-                                tmpl_vars `zip` tmpl_vars1-              bind_wrapper = rs_binds rule_subst-                             -- Floated bindings; see Note [Matching lets]-       ; return (bind_wrapper $-                 mkLams tmpl_vars rhs `mkApps` matched_es) }-  where-    (init_rn_env, tmpl_vars1) = mapAccumL rnBndrL (mkRnEnv2 in_scope) tmpl_vars-                  -- See Note [Cloning the template binders]--    init_menv = RV { rv_tmpls = mkVarSet tmpl_vars1-                   , rv_lcl   = init_rn_env-                   , rv_fltR  = mkEmptySubst (rnInScopeSet init_rn_env)-                   , rv_unf   = id_unf }--    go _    subst []     _      = Just subst-    go _    _     _      []     = Nothing       -- Fail if too few actual args-    go menv subst (t:ts) (e:es) = do { subst1 <- match menv subst t e-                                     ; go menv subst1 ts es }--    lookup_tmpl :: RuleSubst -> TCvSubst -> (InVar,OutVar) -> (TCvSubst, CoreExpr)-                   -- Need to return a RuleSubst solely for the benefit of mk_fake_ty-    lookup_tmpl (RS { rs_tv_subst = tv_subst, rs_id_subst = id_subst })-                tcv_subst (tmpl_var, tmpl_var1)-        | isId tmpl_var1-        = case lookupVarEnv id_subst tmpl_var1 of-            Just e | Coercion co <- e-                   -> (Type.extendCvSubst tcv_subst tmpl_var1 co, Coercion co)-                   | otherwise-                   -> (tcv_subst, e)-            Nothing | Just refl_co <- isReflCoVar_maybe tmpl_var1-                    , let co = Coercion.substCo tcv_subst refl_co-                    -> -- See Note [Unbound RULE binders]-                       (Type.extendCvSubst tcv_subst tmpl_var1 co, Coercion co)-                    | otherwise-                    -> unbound tmpl_var--        | otherwise-        = (Type.extendTvSubst tcv_subst tmpl_var1 ty', Type ty')-        where-          ty' = case lookupVarEnv tv_subst tmpl_var1 of-                  Just ty -> ty-                  Nothing -> fake_ty   -- See Note [Unbound RULE binders]-          fake_ty = anyTypeOfKind (Type.substTy tcv_subst (tyVarKind tmpl_var1))-                    -- This substitution is the sole reason we accumulate-                    -- TCvSubst in lookup_tmpl--    unbound tmpl_var-       = pprPanic "Template variable unbound in rewrite rule" $-         vcat [ text "Variable:" <+> ppr tmpl_var <+> dcolon <+> ppr (varType tmpl_var)-              , text "Rule" <+> pprRuleName rule_name-              , text "Rule bndrs:" <+> ppr tmpl_vars-              , text "LHS args:" <+> ppr tmpl_es-              , text "Actual args:" <+> ppr target_es ]---{- Note [Unbound RULE binders]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It can be the case that the binder in a rule is not actually-bound on the LHS:--* Type variables.  Type synonyms with phantom args can give rise to-  unbound template type variables.  Consider this (#10689,-  simplCore/should_compile/T10689):--    type Foo a b = b--    f :: Eq a => a -> Bool-    f x = x==x--    {-# RULES "foo" forall (x :: Foo a Char). f x = True #-}-    finkle = f 'c'--  The rule looks like-    forall (a::*) (d::Eq Char) (x :: Foo a Char).-         f (Foo a Char) d x = True--  Matching the rule won't bind 'a', and legitimately so.  We fudge by-  pretending that 'a' is bound to (Any :: *).--* Coercion variables.  On the LHS of a RULE for a local binder-  we might have-    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 simplify the LHS (Simplify.simplRule) we-  optCoercion (look at the CoVarCo case) 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.--  It's tricky to be sure this never happens, so instead I-  say it's OK to have an unbound coercion binder in a RULE-  provided its type is (c :: t~t).  Then, when the RULE-  fires we can substitute <t> for c.--  This actually happened (in a RULE for a local function)-  in #13410, and also in test T10602.--Note [Cloning the template binders]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider the following match (example 1):-        Template:  forall x.  f x-        Target:               f (x+1)-This should succeed, because the template variable 'x' has nothing to-do with the 'x' in the target.--Likewise this one (example 2):-        Template:  forall x. f (\x.x)-        Target:              f (\y.y)--We achieve this simply by using rnBndrL to clone the template-binders if they are already in scope.-------- Historical note --------At one point I tried simply adding the template binders to the-in-scope set /without/ cloning them, but that failed in a horribly-obscure way in #14777.  Problem was that during matching we look-up target-term variables in the in-scope set (see Note [Lookup-in-scope]).  If a target-term variable happens to name-clash with a-template variable, that lookup will find the template variable, which-is /utterly/ bogus.  In #14777, this transformed a term variable-into a type variable, and then crashed when we wanted its idInfo.------- End of historical note ----------************************************************************************-*                                                                      *-                   The main matcher-*                                                                      *-********************************************************************* -}---- * The domain of the TvSubstEnv and IdSubstEnv are the template---   variables passed into the match.------ * The BindWrapper in a RuleSubst are the bindings floated out---   from nested matches; see the Let case of match, below----data RuleMatchEnv-  = RV { rv_lcl   :: RnEnv2          -- Renamings for *local bindings*-                                     --   (lambda/case)-       , rv_tmpls :: VarSet          -- Template variables-                                     --   (after applying envL of rv_lcl)-       , rv_fltR  :: Subst           -- Renamings for floated let-bindings-                                     --   (domain disjoint from envR of rv_lcl)-                                     -- See Note [Matching lets]-       , rv_unf :: IdUnfoldingFun-       }--rvInScopeEnv :: RuleMatchEnv -> InScopeEnv-rvInScopeEnv renv = (rnInScopeSet (rv_lcl renv), rv_unf renv)--data RuleSubst = RS { rs_tv_subst :: TvSubstEnv   -- Range is the-                    , rs_id_subst :: IdSubstEnv   --   template variables-                    , rs_binds    :: BindWrapper  -- Floated bindings-                    , rs_bndrs    :: VarSet       -- Variables bound by floated lets-                    }--type BindWrapper = CoreExpr -> CoreExpr-  -- See Notes [Matching lets] and [Matching cases]-  -- we represent the floated bindings as a core-to-core function--emptyRuleSubst :: RuleSubst-emptyRuleSubst = RS { rs_tv_subst = emptyVarEnv, rs_id_subst = emptyVarEnv-                    , rs_binds = \e -> e, rs_bndrs = emptyVarSet }----      At one stage I tried to match even if there are more---      template args than real args.----      I now think this is probably a bad idea.---      Should the template (map f xs) match (map g)?  I think not.---      For a start, in general eta expansion wastes work.---      SLPJ July 99--match :: RuleMatchEnv-      -> RuleSubst-      -> CoreExpr               -- Template-      -> CoreExpr               -- Target-      -> Maybe RuleSubst---- We look through certain ticks. See note [Tick annotations in RULE matching]-match renv subst e1 (Tick t e2)-  | tickishFloatable t-  = match renv subst' e1 e2-  where subst' = subst { rs_binds = rs_binds subst . mkTick t }-match _ _ e@Tick{} _-  = pprPanic "Tick in rule" (ppr e)---- See the notes with Unify.match, which matches types--- Everything is very similar for terms---- Interesting examples:--- Consider matching---      \x->f      against    \f->f--- When we meet the lambdas we must remember to rename f to f' in the--- second expression.  The RnEnv2 does that.------ Consider matching---      forall a. \b->b    against   \a->3--- We must rename the \a.  Otherwise when we meet the lambdas we--- might substitute [a/b] in the template, and then erroneously--- succeed in matching what looks like the template variable 'a' against 3.---- The Var case follows closely what happens in Unify.match-match renv subst (Var v1) e2-  = match_var renv subst v1 e2--match renv subst e1 (Var v2)      -- Note [Expanding variables]-  | not (inRnEnvR rn_env v2) -- Note [Do not expand locally-bound variables]-  , Just e2' <- expandUnfolding_maybe (rv_unf renv v2')-  = match (renv { rv_lcl = nukeRnEnvR rn_env }) subst e1 e2'-  where-    v2'    = lookupRnInScope rn_env v2-    rn_env = rv_lcl renv-        -- Notice that we look up v2 in the in-scope set-        -- See Note [Lookup in-scope]-        -- No need to apply any renaming first (hence no rnOccR)-        -- because of the not-inRnEnvR--match renv subst e1 (Let bind e2)-  | -- pprTrace "match:Let" (vcat [ppr bind, ppr $ okToFloat (rv_lcl renv) (bindFreeVars bind)]) $-    not (isJoinBind bind) -- can't float join point out of argument position-  , okToFloat (rv_lcl renv) (bindFreeVars bind) -- See Note [Matching lets]-  = match (renv { rv_fltR = flt_subst' })-          (subst { rs_binds = rs_binds subst . Let bind'-                 , rs_bndrs = extendVarSetList (rs_bndrs subst) new_bndrs })-          e1 e2-  where-    flt_subst = addInScopeSet (rv_fltR renv) (rs_bndrs subst)-    (flt_subst', bind') = substBind flt_subst bind-    new_bndrs = bindersOf bind'--{- Disabled: see Note [Matching cases] below-match renv (tv_subst, id_subst, binds) e1-      (Case scrut case_bndr ty [(con, alt_bndrs, rhs)])-  | exprOkForSpeculation scrut  -- See Note [Matching cases]-  , okToFloat rn_env bndrs (exprFreeVars scrut)-  = match (renv { me_env = rn_env' })-          (tv_subst, id_subst, binds . case_wrap)-          e1 rhs-  where-    rn_env   = me_env renv-    rn_env'  = extendRnInScopeList rn_env bndrs-    bndrs    = case_bndr : alt_bndrs-    case_wrap rhs' = Case scrut case_bndr ty [(con, alt_bndrs, rhs')]--}--match _ subst (Lit lit1) (Lit lit2)-  | lit1 == lit2-  = Just subst--match renv subst (App f1 a1) (App f2 a2)-  = do  { subst' <- match renv subst f1 f2-        ; match renv subst' a1 a2 }--match renv subst (Lam x1 e1) e2-  | Just (x2, e2, ts) <- exprIsLambda_maybe (rvInScopeEnv renv) e2-  = let renv' = renv { rv_lcl = rnBndr2 (rv_lcl renv) x1 x2-                     , rv_fltR = delBndr (rv_fltR renv) x2 }-        subst' = subst { rs_binds = rs_binds subst . flip (foldr mkTick) ts }-    in  match renv' subst' e1 e2--match renv subst (Case e1 x1 ty1 alts1) (Case e2 x2 ty2 alts2)-  = do  { subst1 <- match_ty renv subst ty1 ty2-        ; subst2 <- match renv subst1 e1 e2-        ; let renv' = rnMatchBndr2 renv subst x1 x2-        ; match_alts renv' subst2 alts1 alts2   -- Alts are both sorted-        }--match renv subst (Type ty1) (Type ty2)-  = match_ty renv subst ty1 ty2-match renv subst (Coercion co1) (Coercion co2)-  = match_co renv subst co1 co2--match renv subst (Cast e1 co1) (Cast e2 co2)-  = do  { subst1 <- match_co renv subst co1 co2-        ; match renv subst1 e1 e2 }---- Everything else fails-match _ _ _e1 _e2 = -- pprTrace "Failing at" ((text "e1:" <+> ppr _e1) $$ (text "e2:" <+> ppr _e2)) $-                    Nothing----------------match_co :: RuleMatchEnv-         -> RuleSubst-         -> Coercion-         -> Coercion-         -> Maybe RuleSubst-match_co renv subst co1 co2-  | Just cv <- getCoVar_maybe co1-  = match_var renv subst cv (Coercion co2)-  | Just (ty1, r1) <- isReflCo_maybe co1-  = do { (ty2, r2) <- isReflCo_maybe co2-       ; guard (r1 == r2)-       ; match_ty renv subst ty1 ty2 }-match_co renv subst co1 co2-  | Just (tc1, cos1) <- splitTyConAppCo_maybe co1-  = case splitTyConAppCo_maybe co2 of-      Just (tc2, cos2)-        |  tc1 == tc2-        -> match_cos renv subst cos1 cos2-      _ -> Nothing-match_co renv subst co1 co2-  | Just (arg1, res1) <- splitFunCo_maybe co1-  = case splitFunCo_maybe co2 of-      Just (arg2, res2)-        -> match_cos renv subst [arg1, res1] [arg2, res2]-      _ -> Nothing-match_co _ _ _co1 _co2-    -- Currently just deals with CoVarCo, TyConAppCo and Refl-#if defined(DEBUG)-  = pprTrace "match_co: needs more cases" (ppr _co1 $$ ppr _co2) Nothing-#else-  = Nothing-#endif--match_cos :: RuleMatchEnv-         -> RuleSubst-         -> [Coercion]-         -> [Coercion]-         -> Maybe RuleSubst-match_cos renv subst (co1:cos1) (co2:cos2) =-  do { subst' <- match_co renv subst co1 co2-     ; match_cos renv subst' cos1 cos2 }-match_cos _ subst [] [] = Just subst-match_cos _ _ cos1 cos2 = pprTrace "match_cos: not same length" (ppr cos1 $$ ppr cos2) Nothing----------------rnMatchBndr2 :: RuleMatchEnv -> RuleSubst -> Var -> Var -> RuleMatchEnv-rnMatchBndr2 renv subst x1 x2-  = renv { rv_lcl  = rnBndr2 rn_env x1 x2-         , rv_fltR = delBndr (rv_fltR renv) x2 }-  where-    rn_env = addRnInScopeSet (rv_lcl renv) (rs_bndrs subst)-    -- Typically this is a no-op, but it may matter if-    -- there are some floated let-bindings---------------------------------------------match_alts :: RuleMatchEnv-           -> RuleSubst-           -> [CoreAlt]         -- Template-           -> [CoreAlt]         -- Target-           -> Maybe RuleSubst-match_alts _ subst [] []-  = return subst-match_alts renv subst ((c1,vs1,r1):alts1) ((c2,vs2,r2):alts2)-  | c1 == c2-  = do  { subst1 <- match renv' subst r1 r2-        ; match_alts renv subst1 alts1 alts2 }-  where-    renv' = foldl' mb renv (vs1 `zip` vs2)-    mb renv (v1,v2) = rnMatchBndr2 renv subst v1 v2--match_alts _ _ _ _-  = Nothing---------------------------------------------okToFloat :: RnEnv2 -> VarSet -> Bool-okToFloat rn_env bind_fvs-  = allVarSet not_captured bind_fvs-  where-    not_captured fv = not (inRnEnvR rn_env fv)---------------------------------------------match_var :: RuleMatchEnv-          -> RuleSubst-          -> Var                -- Template-          -> CoreExpr        -- Target-          -> Maybe RuleSubst-match_var renv@(RV { rv_tmpls = tmpls, rv_lcl = rn_env, rv_fltR = flt_env })-          subst v1 e2-  | v1' `elemVarSet` tmpls-  = match_tmpl_var renv subst v1' e2--  | otherwise   -- v1' is not a template variable; check for an exact match with e2-  = case e2 of  -- Remember, envR of rn_env is disjoint from rv_fltR-       Var v2 | v1' == rnOccR rn_env v2-              -> Just subst--              | Var v2' <- lookupIdSubst (text "match_var") flt_env v2-              , v1' == v2'-              -> Just subst--       _ -> Nothing--  where-    v1' = rnOccL rn_env v1-        -- If the template is-        --      forall x. f x (\x -> x) = ...-        -- Then the x inside the lambda isn't the-        -- template x, so we must rename first!---------------------------------------------match_tmpl_var :: RuleMatchEnv-               -> RuleSubst-               -> Var                -- Template-               -> CoreExpr              -- Target-               -> Maybe RuleSubst--match_tmpl_var renv@(RV { rv_lcl = rn_env, rv_fltR = flt_env })-               subst@(RS { rs_id_subst = id_subst, rs_bndrs = let_bndrs })-               v1' e2-  | any (inRnEnvR rn_env) (exprFreeVarsList e2)-  = Nothing     -- Occurs check failure-                -- e.g. match forall a. (\x-> a x) against (\y. y y)--  | Just e1' <- lookupVarEnv id_subst v1'-  = if eqExpr (rnInScopeSet rn_env) e1' e2'-    then Just subst-    else Nothing--  | otherwise-  =             -- Note [Matching variable types]-                -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-                -- However, we must match the *types*; e.g.-                --   forall (c::Char->Int) (x::Char).-                --      f (c x) = "RULE FIRED"-                -- We must only match on args that have the right type-                -- It's actually quite difficult to come up with an example that shows-                -- you need type matching, esp since matching is left-to-right, so type-                -- args get matched first.  But it's possible (e.g. simplrun008) and-                -- this is the Right Thing to do-    do { subst' <- match_ty renv subst (idType v1') (exprType e2)-       ; return (subst' { rs_id_subst = id_subst' }) }-  where-    -- e2' is the result of applying flt_env to e2-    e2' | isEmptyVarSet let_bndrs = e2-        | otherwise = substExpr (text "match_tmpl_var") flt_env e2--    id_subst' = extendVarEnv (rs_id_subst subst) v1' e2'-         -- No further renaming to do on e2',-         -- because no free var of e2' is in the rnEnvR of the envt---------------------------------------------match_ty :: RuleMatchEnv-         -> RuleSubst-         -> Type                -- Template-         -> Type                -- Target-         -> Maybe RuleSubst--- Matching Core types: use the matcher in TcType.--- Notice that we treat newtypes as opaque.  For example, suppose--- we have a specialised version of a function at a newtype, say---      newtype T = MkT Int--- We only want to replace (f T) with f', not (f Int).--match_ty renv subst ty1 ty2-  = do  { tv_subst'-            <- Unify.ruleMatchTyKiX (rv_tmpls renv) (rv_lcl renv) tv_subst ty1 ty2-        ; return (subst { rs_tv_subst = tv_subst' }) }-  where-    tv_subst = rs_tv_subst subst--{--Note [Expanding variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~-Here is another Very Important rule: if the term being matched is a-variable, we expand it so long as its unfolding is "expandable". (Its-occurrence information is not necessarily up to date, so we don't use-it.)  By "expandable" we mean a WHNF or a "constructor-like" application.-This is the key reason for "constructor-like" Ids.  If we have-     {-# NOINLINE [1] CONLIKE g #-}-     {-# RULE f (g x) = h x #-}-then in the term-   let v = g 3 in ....(f v)....-we want to make the rule fire, to replace (f v) with (h 3).--Note [Do not expand locally-bound variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Do *not* expand locally-bound variables, else there's a worry that the-unfolding might mention variables that are themselves renamed.-Example-          case x of y { (p,q) -> ...y... }-Don't expand 'y' to (p,q) because p,q might themselves have been-renamed.  Essentially we only expand unfoldings that are "outside"-the entire match.--Hence, (a) the guard (not (isLocallyBoundR v2))-       (b) when we expand we nuke the renaming envt (nukeRnEnvR).--Note [Tick annotations in RULE matching]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--We used to unconditionally look through Notes in both template and-expression being matched. This is actually illegal for counting or-cost-centre-scoped ticks, because we have no place to put them without-changing entry counts and/or costs. So now we just fail the match in-these cases.--On the other hand, where we are allowed to insert new cost into the-tick scope, we can float them upwards to the rule application site.--cf Note [Notes in call patterns] in SpecConstr--Note [Matching lets]-~~~~~~~~~~~~~~~~~~~~-Matching a let-expression.  Consider-        RULE forall x.  f (g x) = <rhs>-and target expression-        f (let { w=R } in g E))-Then we'd like the rule to match, to generate-        let { w=R } in (\x. <rhs>) E-In effect, we want to float the let-binding outward, to enable-the match to happen.  This is the WHOLE REASON for accumulating-bindings in the RuleSubst--We can only do this if the free variables of R are not bound by the-part of the target expression outside the let binding; e.g.-        f (\v. let w = v+1 in g E)-Here we obviously cannot float the let-binding for w.  Hence the-use of okToFloat.--There are a couple of tricky points.-  (a) What if floating the binding captures a variable?-        f (let v = x+1 in v) v-      --> NOT!-        let v = x+1 in f (x+1) v--  (b) What if two non-nested let bindings bind the same variable?-        f (let v = e1 in b1) (let v = e2 in b2)-      --> NOT!-        let v = e1 in let v = e2 in (f b2 b2)-      See testsuite test "RuleFloatLet".--Our cunning plan is this:-  * Along with the growing substitution for template variables-    we maintain a growing set of floated let-bindings (rs_binds)-    plus the set of variables thus bound.--  * The RnEnv2 in the MatchEnv binds only the local binders-    in the term (lambdas, case)--  * When we encounter a let in the term to be matched, we-    check that does not mention any locally bound (lambda, case)-    variables.  If so we fail--  * We use CoreSubst.substBind to freshen the binding, using an-    in-scope set that is the original in-scope variables plus the-    rs_bndrs (currently floated let-bindings).  So in (a) above-    we'll freshen the 'v' binding; in (b) above we'll freshen-    the *second* 'v' binding.--  * We apply that freshening substitution, in a lexically-scoped-    way to the term, although lazily; this is the rv_fltR field.---Note [Matching cases]-~~~~~~~~~~~~~~~~~~~~~-{- NOTE: This idea is currently disabled.  It really only works if-         the primops involved are OkForSpeculation, and, since-         they have side effects readIntOfAddr and touch are not.-         Maybe we'll get back to this later .  -}--Consider-   f (case readIntOffAddr# p# i# realWorld# of { (# s#, n# #) ->-      case touch# fp s# of { _ ->-      I# n# } } )-This happened in a tight loop generated by stream fusion that-Roman encountered.  We'd like to treat this just like the let-case, because the primops concerned are ok-for-speculation.-That is, we'd like to behave as if it had been-   case readIntOffAddr# p# i# realWorld# of { (# s#, n# #) ->-   case touch# fp s# of { _ ->-   f (I# n# } } )--Note [Lookup in-scope]-~~~~~~~~~~~~~~~~~~~~~~-Consider this example-        foo :: Int -> Maybe Int -> Int-        foo 0 (Just n) = n-        foo m (Just n) = foo (m-n) (Just n)--SpecConstr sees this fragment:--        case w_smT of wild_Xf [Just A] {-          Data.Maybe.Nothing -> lvl_smf;-          Data.Maybe.Just n_acT [Just S(L)] ->-            case n_acT of wild1_ams [Just A] { GHC.Base.I# y_amr [Just L] ->-              $wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf-            }};--and correctly generates the rule--        RULES: "SC:$wfoo1" [0] __forall {y_amr [Just L] :: GHC.Prim.Int#-                                          sc_snn :: GHC.Prim.Int#}-          $wfoo_smW sc_snn (Data.Maybe.Just @ GHC.Base.Int (GHC.Base.I# y_amr))-          = $s$wfoo_sno y_amr sc_snn ;]--BUT we must ensure that this rule matches in the original function!-Note that the call to $wfoo is-            $wfoo_smW (GHC.Prim.-# ds_Xmb y_amr) wild_Xf--During matching we expand wild_Xf to (Just n_acT).  But then we must also-expand n_acT to (I# y_amr).  And we can only do that if we look up n_acT-in the in-scope set, because in wild_Xf's unfolding it won't have an unfolding-at all.--That is why the 'lookupRnInScope' call in the (Var v2) case of 'match'-is so important.---************************************************************************-*                                                                      *-                   Rule-check the program-*                                                                      *-************************************************************************--   We want to know what sites have rules that could have fired but didn't.-   This pass runs over the tree (without changing it) and reports such.--}---- | Report partial matches for rules beginning with the specified--- string for the purposes of error reporting-ruleCheckProgram :: CompilerPhase               -- ^ Rule activation test-                 -> String                      -- ^ Rule pattern-                 -> (Id -> [CoreRule])          -- ^ Rules for an Id-                 -> CoreProgram                 -- ^ Bindings to check in-                 -> SDoc                        -- ^ Resulting check message-ruleCheckProgram phase rule_pat rules binds-  | isEmptyBag results-  = text "Rule check results: no rule application sites"-  | otherwise-  = vcat [text "Rule check results:",-          line,-          vcat [ p $$ line | p <- bagToList results ]-         ]-  where-    env = RuleCheckEnv { rc_is_active = isActive phase-                       , rc_id_unf    = idUnfolding     -- Not quite right-                                                        -- Should use activeUnfolding-                       , rc_pattern   = rule_pat-                       , rc_rules = rules }-    results = unionManyBags (map (ruleCheckBind env) binds)-    line = text (replicate 20 '-')--data RuleCheckEnv = RuleCheckEnv {-    rc_is_active :: Activation -> Bool,-    rc_id_unf  :: IdUnfoldingFun,-    rc_pattern :: String,-    rc_rules :: Id -> [CoreRule]-}--ruleCheckBind :: RuleCheckEnv -> CoreBind -> Bag SDoc-   -- The Bag returned has one SDoc for each call site found-ruleCheckBind env (NonRec _ r) = ruleCheck env r-ruleCheckBind env (Rec prs)    = unionManyBags [ruleCheck env r | (_,r) <- prs]--ruleCheck :: RuleCheckEnv -> CoreExpr -> Bag SDoc-ruleCheck _   (Var _)       = emptyBag-ruleCheck _   (Lit _)       = emptyBag-ruleCheck _   (Type _)      = emptyBag-ruleCheck _   (Coercion _)  = emptyBag-ruleCheck env (App f a)     = ruleCheckApp env (App f a) []-ruleCheck env (Tick _ e)  = ruleCheck env e-ruleCheck env (Cast e _)    = ruleCheck env e-ruleCheck env (Let bd e)    = ruleCheckBind env bd `unionBags` ruleCheck env e-ruleCheck env (Lam _ e)     = ruleCheck env e-ruleCheck env (Case e _ _ as) = ruleCheck env e `unionBags`-                                unionManyBags [ruleCheck env r | (_,_,r) <- as]--ruleCheckApp :: RuleCheckEnv -> Expr CoreBndr -> [Arg CoreBndr] -> Bag SDoc-ruleCheckApp env (App f a) as = ruleCheck env a `unionBags` ruleCheckApp env f (a:as)-ruleCheckApp env (Var f) as   = ruleCheckFun env f as-ruleCheckApp env other _      = ruleCheck env other--ruleCheckFun :: RuleCheckEnv -> Id -> [CoreExpr] -> Bag SDoc--- Produce a report for all rules matching the predicate--- saying why it doesn't match the specified application--ruleCheckFun env fn args-  | null name_match_rules = emptyBag-  | otherwise             = unitBag (ruleAppCheck_help env fn args name_match_rules)-  where-    name_match_rules = filter match (rc_rules env fn)-    match rule = (rc_pattern env) `isPrefixOf` unpackFS (ruleName rule)--ruleAppCheck_help :: RuleCheckEnv -> Id -> [CoreExpr] -> [CoreRule] -> SDoc-ruleAppCheck_help env fn args rules-  =     -- The rules match the pattern, so we want to print something-    vcat [text "Expression:" <+> ppr (mkApps (Var fn) args),-          vcat (map check_rule rules)]-  where-    n_args = length args-    i_args = args `zip` [1::Int ..]-    rough_args = map roughTopName args--    check_rule rule = sdocWithDynFlags $ \dflags ->-                      rule_herald rule <> colon <+> rule_info dflags rule--    rule_herald (BuiltinRule { ru_name = name })-        = text "Builtin rule" <+> doubleQuotes (ftext name)-    rule_herald (Rule { ru_name = name })-        = text "Rule" <+> doubleQuotes (ftext name)--    rule_info dflags rule-        | Just _ <- matchRule dflags (emptyInScopeSet, rc_id_unf env)-                              noBlackList fn args rough_args rule-        = text "matches (which is very peculiar!)"--    rule_info _ (BuiltinRule {}) = text "does not match"--    rule_info _ (Rule { ru_act = act,-                        ru_bndrs = rule_bndrs, ru_args = rule_args})-        | not (rc_is_active env act)  = text "active only in later phase"-        | n_args < n_rule_args        = text "too few arguments"-        | n_mismatches == n_rule_args = text "no arguments match"-        | n_mismatches == 0           = text "all arguments match (considered individually), but rule as a whole does not"-        | otherwise                   = text "arguments" <+> ppr mismatches <+> text "do not match (1-indexing)"-        where-          n_rule_args  = length rule_args-          n_mismatches = length mismatches-          mismatches   = [i | (rule_arg, (arg,i)) <- rule_args `zip` i_args,-                              not (isJust (match_fn rule_arg arg))]--          lhs_fvs = exprsFreeVars rule_args     -- Includes template tyvars-          match_fn rule_arg arg = match renv emptyRuleSubst rule_arg arg-                where-                  in_scope = mkInScopeSet (lhs_fvs `unionVarSet` exprFreeVars arg)-                  renv = RV { rv_lcl   = mkRnEnv2 in_scope-                            , rv_tmpls = mkVarSet rule_bndrs-                            , rv_fltR  = mkEmptySubst in_scope-                            , rv_unf   = rc_id_unf env }

compiler/typecheck/Constraint.hs view

@@ -92,13 +92,13 @@ import TcEvidence import TcOrigin -import CoreSyn+import GHC.Core  import TyCoPpr import OccName import FV import VarSet-import DynFlags+import GHC.Driver.Session import BasicTypes  import Outputable@@ -764,7 +764,7 @@ isPendingScDict _ = Nothing  isPendingScInst :: QCInst -> Maybe QCInst--- Same as isPrendinScDict, but for QCInsts+-- Same as isPendingScDict, but for QCInsts isPendingScInst qci@(QCI { qci_pend_sc = True })                   = Just (qci { qci_pend_sc = False }) isPendingScInst _ = Nothing@@ -1175,9 +1175,17 @@  The kind of 'a' mentions 'k' which is bound after 'a'.  Oops. -Knowing this means that unification etc must have happened, so it's-convenient to detect it in the constraint solver:+One approach to doing this would be to bring each of a, k, and b into+scope, one at a time, creating a separate implication constraint for+each one, and bumping the TcLevel. This would work, because the kind+of, say, a would be untouchable when k is in scope (and the constraint+couldn't float out because k blocks it). However, it leads to terrible+error messages, complaining about skolem escape. While it is indeed a+problem of skolem escape, we can do better. +Instead, our approach is to bring the block of variables into scope+all at once, creating one implication constraint for the lot:+ * We make a single implication constraint when kind-checking   the 'forall' in Foo's kind, something like       forall a k (b::k). { wanted constraints }@@ -1200,8 +1208,6 @@   ic_telescope, even if ic_wanted is empty.  We must give the   constraint solver a chance to make that bad-telescope test!  Hence   the extra guard in emitResidualTvConstraint; see #16247--See also TcHsType Note [Keeping scoped variables in order: Explicit]  Note [Needed evidence variables] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

compiler/typecheck/TcEvidence.hs view

@@ -1,6 +1,7 @@ -- (c) The University of Glasgow 2006  {-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# LANGUAGE LambdaCase #-}  module TcEvidence ( @@ -57,23 +58,22 @@ import Var import CoAxiom import Coercion-import PprCore ()   -- Instance OutputableBndr TyVar+import GHC.Core.Ppr ()   -- Instance OutputableBndr TyVar import TcType import Type import TyCon import DataCon( DataCon, dataConWrapId ) import Class( Class ) import PrelNames-import DynFlags   ( gopt, GeneralFlag(Opt_PrintTypecheckerElaboration) ) import VarEnv import VarSet import Predicate import Name import Pair -import CoreSyn+import GHC.Core import Class ( classSCSelId )-import CoreFVs ( exprSomeFreeVars )+import GHC.Core.FVs ( exprSomeFreeVars )  import Util import Bag@@ -212,7 +212,7 @@        -- The TcType is the "from" type of the first wrapper        -- The SDoc explains the circumstances under which we have created this        -- WpFun, in case we run afoul of levity polymorphism restrictions in-       -- the desugarer. See Note [Levity polymorphism checking] in DsMonad+       -- the desugarer. See Note [Levity polymorphism checking] in GHC.HsToCore.Monad    | WpCast TcCoercionR        -- A cast:  [] `cast` co                               -- Guaranteed not the identity coercion@@ -362,7 +362,6 @@   where     go WpHole                  = True     go (WpCompose wrap1 wrap2) = go wrap1 && go wrap2-    -- not so sure about WpFun. But it eta-expands, so...     go WpFun{}                 = False     go WpCast{}                = True     go WpEvLam{}               = False -- case in point@@ -782,7 +781,7 @@  - An EvCallStack term desugars to a CoreExpr of type `IP "some str" CallStack`.   The desugarer will need to unwrap the IP newtype before pushing a new-  call-site onto a given stack (See DsBinds.dsEvCallStack)+  call-site onto a given stack (See GHC.HsToCore.Binds.dsEvCallStack)  - When we emit a new wanted CallStack from rule (2) we set its origin to   `IPOccOrigin ip_name` instead of the original `OccurrenceOf func`@@ -912,10 +911,9 @@ -- The pp_thing_inside function takes Bool to say whether --    it's in a position that needs parens for a non-atomic thing pprHsWrapper wrap pp_thing_inside-  = sdocWithDynFlags $ \ dflags ->-    if gopt Opt_PrintTypecheckerElaboration dflags-    then help pp_thing_inside wrap False-    else pp_thing_inside False+  = sdocOption sdocPrintTypecheckerElaboration $ \case+      True  -> help pp_thing_inside wrap False+      False -> pp_thing_inside False   where     help :: (Bool -> SDoc) -> HsWrapper -> Bool -> SDoc     -- True  <=> appears in function application position

compiler/typecheck/TcOrigin.hs view

@@ -6,6 +6,7 @@ -}  {-# LANGUAGE CPP #-}+{-# LANGUAGE LambdaCase #-}  {-# OPTIONS_GHC -Wno-incomplete-record-updates #-} {-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}@@ -42,8 +43,6 @@ import Module import Name import RdrName-import qualified GHC.LanguageExtensions as LangExt-import DynFlags  import SrcLoc import FastString@@ -205,7 +204,7 @@   | FamInstSkol         -- Bound at a family instance decl   | PatSkol             -- An existential type variable bound by a pattern for       ConLike           -- a data constructor with an existential type.-      (HsMatchContext Name)+      (HsMatchContext GhcRn)              -- e.g.   data T = forall a. Eq a => MkT a              --        f (MkT x) = ...              -- The pattern MkT x will allocate an existential type@@ -237,6 +236,8 @@   | QuantCtxtSkol       -- Quantified context, e.g.                         --   f :: forall c. (forall a. c a => c [a]) => blah +  | RuntimeUnkSkol      -- Runtime skolem from the GHCi debugger      #14628+   | UnkSkol             -- Unhelpful info (until I improve it)  instance Outputable SkolemInfo where@@ -267,6 +268,7 @@ pprSkolInfo ReifySkol         = text "the type being reified"  pprSkolInfo (QuantCtxtSkol {}) = text "a quantified context"+pprSkolInfo RuntimeUnkSkol     = text "Unknown type from GHCi runtime"  -- UnkSkol -- For type variables the others are dealt with by pprSkolTvBinding.@@ -435,10 +437,6 @@   | ListOrigin          -- An overloaded list   | BracketOrigin       -- An overloaded quotation bracket   | StaticOrigin        -- A static form-  | FailablePattern (LPat GhcTcId) -- A failable pattern in do-notation for the-                                   -- MonadFail Proposal (MFP). Obsolete when-                                   -- actual desugaring to MonadFail.fail is-                                   -- live.   | Shouldn'tHappenOrigin String                             -- the user should never see this one,                             -- unless ImpredicativeTypes is on, where all@@ -498,7 +496,7 @@ exprCtOrigin (ExplicitTuple {})   = Shouldn'tHappenOrigin "explicit tuple" exprCtOrigin ExplicitSum{}        = Shouldn'tHappenOrigin "explicit sum" exprCtOrigin (HsCase _ _ matches) = matchesCtOrigin matches-exprCtOrigin (HsIf _ (Just syn) _ _ _) = exprCtOrigin (syn_expr syn)+exprCtOrigin (HsIf _ (SyntaxExprRn syn) _ _ _) = exprCtOrigin syn exprCtOrigin (HsIf {})           = Shouldn'tHappenOrigin "if expression" exprCtOrigin (HsMultiIf _ rhs)   = lGRHSCtOrigin rhs exprCtOrigin (HsLet _ _ e)       = lexprCtOrigin e@@ -517,7 +515,6 @@ exprCtOrigin (HsStatic {})       = Shouldn'tHappenOrigin "static expression" exprCtOrigin (HsTick _ _ e)           = lexprCtOrigin e exprCtOrigin (HsBinTick _ _ _ e)      = lexprCtOrigin e-exprCtOrigin (HsWrap {})        = panic "exprCtOrigin HsWrap" exprCtOrigin (XExpr nec)        = noExtCon nec  -- | Extract a suitable CtOrigin from a MatchGroup@@ -600,19 +597,15 @@     = ctoHerald <+> hsep [ text "the failable pattern"            , quotes (ppr pat)            , text "in a statement in a monad comprehension" ]-pprCtOrigin (FailablePattern pat)-    = ctoHerald <+> text "the failable pattern" <+> quotes (ppr pat)-      $$-      text "(this will become an error in a future GHC release)"  pprCtOrigin (Shouldn'tHappenOrigin note)-  = sdocWithDynFlags $ \dflags ->-    if xopt LangExt.ImpredicativeTypes dflags-    then text "a situation created by impredicative types"-    else-    vcat [ text "<< This should not appear in error messages. If you see this"-         , text "in an error message, please report a bug mentioning" <+> quotes (text note) <+> text "at"-         , text "https://gitlab.haskell.org/ghc/ghc/wikis/report-a-bug >>" ]+  = sdocOption sdocImpredicativeTypes $ \case+      True  -> text "a situation created by impredicative types"+      False -> vcat [ text "<< This should not appear in error messages. If you see this"+                    , text "in an error message, please report a bug mentioning"+                        <+> quotes (text note) <+> text "at"+                    , text "https://gitlab.haskell.org/ghc/ghc/wikis/report-a-bug >>"+                    ]  pprCtOrigin (ProvCtxtOrigin PSB{ psb_id = (L _ name) })   = hang (ctoHerald <+> text "the \"provided\" constraints claimed by")

compiler/typecheck/TcRnTypes.hs view

@@ -86,7 +86,7 @@ import GhcPrelude  import GHC.Hs-import HscTypes+import GHC.Driver.Types import TcEvidence import Type import TyCon    ( TyCon, tyConKind )@@ -99,7 +99,7 @@ import Annotations import InstEnv import FamInstEnv-import {-# SOURCE #-} GHC.HsToCore.PmCheck.Types (Delta)+import {-# SOURCE #-} GHC.HsToCore.PmCheck.Types (Deltas) import IOEnv import RdrName import Name@@ -115,7 +115,7 @@ import UniqFM import BasicTypes import Bag-import DynFlags+import GHC.Driver.Session import Outputable import ListSetOps import Fingerprint@@ -317,9 +317,9 @@         dsl_loc     :: RealSrcSpan,      -- To put in pattern-matching error msgs          -- See Note [Note [Type and Term Equality Propagation] in Check.hs-        -- The oracle state Delta is augmented as we walk inwards,-        -- through each pattern match in turn-        dsl_delta   :: Delta+        -- The set of reaching values Deltas is augmented as we walk inwards,+        -- refined through each pattern match in turn+        dsl_deltas  :: Deltas      }  -- Inside [| |] brackets, the desugarer looks@@ -343,13 +343,11 @@ ************************************************************************ -} --- | 'FrontendResult' describes the result of running the--- frontend of a Haskell module.  Usually, you'll get--- a 'FrontendTypecheck', since running the frontend involves--- typechecking a program, but for an hs-boot merge you'll--- just get a ModIface, since no actual typechecking occurred.+-- | 'FrontendResult' describes the result of running the frontend of a Haskell+-- module. Currently one always gets a 'FrontendTypecheck', since running the+-- frontend involves typechecking a program. hs-sig merges are not handled here. ----- This data type really should be in HscTypes, but it needs+-- This data type really should be in GHC.Driver.Types, but it needs -- to have a TcGblEnv which is only defined here. data FrontendResult         = FrontendTypecheck TcGblEnv@@ -419,7 +417,7 @@          tcg_fix_env   :: FixityEnv,     -- ^ Just for things in this module         tcg_field_env :: RecFieldEnv,   -- ^ Just for things in this module-                                        -- See Note [The interactive package] in HscTypes+                                        -- See Note [The interactive package] in GHC.Driver.Types          tcg_type_env :: TypeEnv,           -- ^ Global type env for the module we are compiling now.  All@@ -430,7 +428,7 @@           --  move to the global envt during zonking)           --           -- NB: for what "things in this module" means, see-          -- Note [The interactive package] in HscTypes+          -- Note [The interactive package] in GHC.Driver.Types          tcg_type_env_var :: TcRef TypeEnv,                 -- Used only to initialise the interface-file@@ -477,7 +475,7 @@           --      (tcRnExports)           --    - imp_mods is used to compute usage info (mkIfaceTc, deSugar)           --    - imp_trust_own_pkg is used for Safe Haskell in interfaces-          --      (mkIfaceTc, as well as in HscMain)+          --      (mkIfaceTc, as well as in GHC.Driver.Main)           --    - To create the Dependencies field in interface (mkDependencies)            -- These three fields track unused bindings and imports@@ -553,7 +551,7 @@          -- Things defined in this module, or (in GHCi)         -- in the declarations for a single GHCi command.-        -- For the latter, see Note [The interactive package] in HscTypes+        -- For the latter, see Note [The interactive package] in GHC.Driver.Types         tcg_tr_module :: Maybe Id,   -- Id for $trModule :: GHC.Types.Module                                              -- for which every module has a top-level defn                                              -- except in GHCi in which case we have Nothing@@ -1328,7 +1326,7 @@           --      = ModuleEnv [ImportedModsVal],           -- ^ Domain is all directly-imported modules           ---          -- See the documentation on ImportedModsVal in HscTypes for the+          -- See the documentation on ImportedModsVal in GHC.Driver.Types for the           -- meaning of the fields.           --           -- We need a full ModuleEnv rather than a ModuleNameEnv here,

compiler/typecheck/TcType.hs view

@@ -208,8 +208,8 @@ import TyCon  -- others:-import DynFlags-import CoreFVs+import GHC.Driver.Session+import GHC.Core.FVs import Name -- hiding (varName)             -- We use this to make dictionaries for type literals.             -- Perhaps there's a better way to do this?@@ -898,6 +898,42 @@ out the other (#14363). -} +{- *********************************************************************+*                                                                      *+          The "exact" free variables of a type+*                                                                      *+********************************************************************* -}++{- Note [Silly type synonym]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+  type T a = Int+What are the free tyvars of (T x)?  Empty, of course!++exactTyCoVarsOfType is used by the type checker to figure out exactly+which type variables are mentioned in a type.  It only matters+occasionally -- see the calls to exactTyCoVarsOfType.++We place this function here in TcType, note in TyCoFVs,+because we want to "see" tcView (efficiency issue only).+-}++exactTyCoVarsOfType  :: Type   -> TyCoVarSet+exactTyCoVarsOfTypes :: [Type] -> TyCoVarSet+-- Find the free type variables (of any kind)+-- but *expand* type synonyms.  See Note [Silly type synonym] above.++exactTyCoVarsOfType  ty  = runTyCoVars (exact_ty ty)+exactTyCoVarsOfTypes tys = runTyCoVars (exact_tys tys)++exact_ty  :: Type       -> Endo TyCoVarSet+exact_tys :: [Type]     -> Endo TyCoVarSet+(exact_ty, exact_tys, _, _) = foldTyCo exactTcvFolder emptyVarSet++exactTcvFolder :: TyCoFolder TyCoVarSet (Endo TyCoVarSet)+exactTcvFolder = deepTcvFolder { tcf_view = tcView }+                 -- This is the key line+ {- ************************************************************************ *                                                                      *@@ -989,7 +1025,7 @@ -- isAmbiguousTyVar is used only when reporting type errors -- It picks out variables that are unbound, namely meta -- type variables and the RuntimUnk variables created by--- RtClosureInspect.zonkRTTIType.  These are "ambiguous" in+-- GHC.Runtime.Heap.Inspect.zonkRTTIType.  These are "ambiguous" in -- the sense that they stand for an as-yet-unknown type isAmbiguousTyVar tv   | isTyVar tv -- See Note [Coercion variables in free variable lists]

compiler/types/CoAxiom.hs view

@@ -203,7 +203,7 @@ -- | A 'CoAxiom' is a \"coercion constructor\", i.e. a named equality axiom.  -- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs+-- See Note [GHC Formalism] in GHC.Core.Lint data CoAxiom br   = CoAxiom                   -- Type equality axiom.     { co_ax_unique   :: Unique        -- Unique identifier@@ -366,7 +366,7 @@  Note [Implicit axioms] ~~~~~~~~~~~~~~~~~~~~~~-See also Note [Implicit TyThings] in HscTypes+See also Note [Implicit TyThings] in GHC.Driver.Types * A CoAxiom arising from data/type family instances is not "implicit".   That is, it has its own IfaceAxiom declaration in an interface file

compiler/types/Coercion.hs view

@@ -6,7 +6,7 @@              ScopedTypeVariables #-}  -- | Module for (a) type kinds and (b) type coercions,--- as used in System FC. See 'CoreSyn.Expr' for+-- as used in System FC. See 'GHC.Core.Expr' for -- more on System FC and how coercions fit into it. -- module Coercion (@@ -35,7 +35,7 @@         mkInstCo, mkAppCo, mkAppCos, mkTyConAppCo, mkFunCo,         mkForAllCo, mkForAllCos, mkHomoForAllCos,         mkPhantomCo,-        mkUnsafeCo, mkHoleCo, mkUnivCo, mkSubCo,+        mkHoleCo, mkUnivCo, mkSubCo,         mkAxiomInstCo, mkProofIrrelCo,         downgradeRole, mkAxiomRuleCo,         mkGReflRightCo, mkGReflLeftCo, mkCoherenceLeftCo, mkCoherenceRightCo,@@ -637,8 +637,7 @@  Note that setNominalRole_maybe will never upgrade a phantom UnivCo. Phantom UnivCos are perfectly type-safe, whereas representational and nominal ones are-not. Indeed, `unsafeCoerce` is implemented via a representational UnivCo.-(Nominal ones are no worse than representational ones, so this function *will*+not. (Nominal ones are no worse than representational ones, so this function *will* change a UnivCo Representational to a UnivCo Nominal.)  Conal Elliott also came across a need for this function while working with the@@ -848,7 +847,7 @@ {- Note [mkCoVarCo] ~~~~~~~~~~~~~~~~~~~ In the past, mkCoVarCo optimised (c :: t~t) to (Refl t).  That is-valid (although see Note [Unbound RULE binders] in Rules), but+valid (although see Note [Unbound RULE binders] in GHC.Core.Rules), but it's a relatively expensive test and perhaps better done in optCoercion.  Not a big deal either way. -}@@ -936,14 +935,6 @@ mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type mkUnbranchedAxInstLHS ax = mkAxInstLHS ax 0 --- | Manufacture an unsafe coercion from thin air.---   Currently (May 14) this is used only to implement the---   @unsafeCoerce#@ primitive.  Optimise by pushing---   down through type constructors.-mkUnsafeCo :: Role -> Type -> Type -> Coercion-mkUnsafeCo role ty1 ty2-  = mkUnivCo UnsafeCoerceProv role ty1 ty2- -- | Make a coercion from a coercion hole mkHoleCo :: CoercionHole -> Coercion mkHoleCo h = HoleCo h@@ -1281,8 +1272,7 @@     setNominalRole_maybe_helper (InstCo co arg)       = InstCo <$> setNominalRole_maybe_helper co <*> pure arg     setNominalRole_maybe_helper (UnivCo prov _ co1 co2)-      | case prov of UnsafeCoerceProv -> True   -- it's always unsafe-                     PhantomProv _    -> False  -- should always be phantom+      | case prov of PhantomProv _    -> False  -- should always be phantom                      ProofIrrelProv _ -> True   -- it's always safe                      PluginProv _     -> False  -- who knows? This choice is conservative.       = Just $ UnivCo prov Nominal co1 co2@@ -1388,7 +1378,6 @@     AxiomInstCo {} -> mkKindCo co     AxiomRuleCo {} -> mkKindCo co -    UnivCo UnsafeCoerceProv _ t1 t2   -> mkUnsafeCo Nominal (typeKind t1) (typeKind t2)     UnivCo (PhantomProv kco) _ _ _    -> kco     UnivCo (ProofIrrelProv kco) _ _ _ -> kco     UnivCo (PluginProv _) _ _ _       -> mkKindCo co@@ -2145,7 +2134,6 @@ seqCo (AxiomRuleCo _ cs)        = seqCos cs  seqProv :: UnivCoProvenance -> ()-seqProv UnsafeCoerceProv    = () seqProv (PhantomProv co)    = seqCo co seqProv (ProofIrrelProv co) = seqCo co seqProv (PluginProv _)      = ()

compiler/types/Coercion.hs-boot view

@@ -21,7 +21,6 @@ mkCoVarCo :: CoVar -> Coercion mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion mkPhantomCo :: Coercion -> Type -> Type -> Coercion-mkUnsafeCo :: Role -> Type -> Type -> Coercion mkUnivCo :: UnivCoProvenance -> Role -> Type -> Type -> Coercion mkSymCo :: Coercion -> Coercion mkTransCo :: Coercion -> Coercion -> Coercion

compiler/types/FamInstEnv.hs view

@@ -55,7 +55,7 @@ import UniqDFM import Outputable import Maybes-import CoreMap+import GHC.Core.Map import Unique import Util import Var@@ -220,7 +220,7 @@ pprFamInst :: FamInst -> SDoc -- Prints the FamInst as a family instance declaration -- NB: This function, FamInstEnv.pprFamInst, is used only for internal,---     debug printing. See PprTyThing.pprFamInst for printing for the user+--     debug printing. See GHC.Core.Ppr.TyThing.pprFamInst for printing for the user pprFamInst (FamInst { fi_flavor = flavor, fi_axiom = ax                     , fi_tvs = tvs, fi_tys = tys, fi_rhs = rhs })   = hang (ppr_tc_sort <+> text "instance"

compiler/types/InstEnv.hs view

@@ -35,7 +35,7 @@  import TcType -- InstEnv is really part of the type checker,               -- and depends on TcType in many ways-import CoreSyn ( IsOrphan(..), isOrphan, chooseOrphanAnchor )+import GHC.Core ( IsOrphan(..), isOrphan, chooseOrphanAnchor ) import Module import Class import Var

compiler/types/OptCoercion.hs view

@@ -8,7 +8,7 @@  import GhcPrelude -import DynFlags+import GHC.Driver.Session import TyCoRep import TyCoSubst import Coercion@@ -554,7 +554,6 @@    where     prov' = case prov of-      UnsafeCoerceProv   -> prov       PhantomProv kco    -> PhantomProv $ opt_co4_wrap env sym False Nominal kco       ProofIrrelProv kco -> ProofIrrelProv $ opt_co4_wrap env sym False Nominal kco       PluginProv _       -> prov@@ -634,7 +633,6 @@     mkUnivCo prov' r1 tyl1 tyr2   where     -- if the provenances are different, opt'ing will be very confusing-    opt_trans_prov UnsafeCoerceProv      UnsafeCoerceProv      = Just UnsafeCoerceProv     opt_trans_prov (PhantomProv kco1)    (PhantomProv kco2)       = Just $ PhantomProv $ opt_trans is kco1 kco2     opt_trans_prov (ProofIrrelProv kco1) (ProofIrrelProv kco2)@@ -969,7 +967,7 @@ checkAxInstCo :: Coercion -> Maybe CoAxBranch -- defined here to avoid dependencies in Coercion -- If you edit this function, you may need to update the GHC formalism--- See Note [GHC Formalism] in CoreLint+-- See Note [GHC Formalism] in GHC.Core.Lint checkAxInstCo (AxiomInstCo ax ind cos)   = let branch       = coAxiomNthBranch ax ind         tvs          = coAxBranchTyVars branch

compiler/types/TyCoFVs.hs view

@@ -1,34 +1,53 @@+{-# LANGUAGE CPP #-}+ module TyCoFVs-  (-        tyCoVarsOfType, tyCoVarsOfTypeDSet, tyCoVarsOfTypes, tyCoVarsOfTypesDSet,-        exactTyCoVarsOfType, exactTyCoVarsOfTypes,+  (     shallowTyCoVarsOfType, shallowTyCoVarsOfTypes,+        tyCoVarsOfType,        tyCoVarsOfTypes,+        tyCoVarsOfTypeDSet, tyCoVarsOfTypesDSet,+         tyCoFVsBndr, tyCoFVsVarBndr, tyCoFVsVarBndrs,         tyCoFVsOfType, tyCoVarsOfTypeList,         tyCoFVsOfTypes, tyCoVarsOfTypesList,-        tyCoVarsOfTypesSet, tyCoVarsOfCosSet,+        deepTcvFolder,++        shallowTyCoVarsOfTyVarEnv, shallowTyCoVarsOfCoVarEnv,++        shallowTyCoVarsOfCo, shallowTyCoVarsOfCos,+        tyCoVarsOfCo,        tyCoVarsOfCos,         coVarsOfType, coVarsOfTypes,         coVarsOfCo, coVarsOfCos,-        tyCoVarsOfCo, tyCoVarsOfCos,         tyCoVarsOfCoDSet,         tyCoFVsOfCo, tyCoFVsOfCos,-        tyCoVarsOfCoList, tyCoVarsOfProv,+        tyCoVarsOfCoList,+         almostDevoidCoVarOfCo,++        -- Injective free vars         injectiveVarsOfType, injectiveVarsOfTypes,         invisibleVarsOfType, invisibleVarsOfTypes, +        -- No Free vars         noFreeVarsOfType, noFreeVarsOfTypes, noFreeVarsOfCo, -        mkTyCoInScopeSet,--        -- * Welll-scoped free variables+        -- * Well-scoped free variables         scopedSort, tyCoVarsOfTypeWellScoped,         tyCoVarsOfTypesWellScoped,++        -- * Closing over kinds+        closeOverKindsDSet, closeOverKindsList,+        closeOverKinds,++        -- * Raw materials+        Endo(..), runTyCoVars   ) where +#include "HsVersions.h"+ import GhcPrelude -import {-# SOURCE #-} Type (coreView, tcView, partitionInvisibleTypes)+import {-# SOURCE #-} Type   (coreView, partitionInvisibleTypes) +import Data.Monoid as DM ( Endo(..), All(..) ) import TyCoRep import TyCon import Var@@ -48,6 +67,31 @@ %************************************************************************ -} +{- Note [Shallow and deep free variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Definitions++* Shallow free variables of a type: the variables+  affected by substitution. Specifically, the (TyVarTy tv)+  and (CoVar cv) that appear+    - In the type and coercions appearing in the type+    - In shallow free variables of the kind of a Forall binder+  but NOT in the kind of the /occurrences/ of a type variable.++* Deep free variables of a type: shallow free variables, plus+  the deep free variables of the kinds of those variables.+  That is,  deepFVs( t ) = closeOverKinds( shallowFVs( t ) )++Examples:++  Type                     Shallow     Deep+  ---------------------------------+  (a : (k:Type))           {a}        {a,k}+  forall (a:(k:Type)). a   {k}        {k}+  (a:k->Type) (b:k)        {a,b}      {a,b,k}+-}++ {- Note [Free variables of types] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The family of functions tyCoVarsOfType, tyCoVarsOfTypes etc, returns@@ -170,103 +214,313 @@ kind are free. -} +{- *********************************************************************+*                                                                      *+          Endo for free variables+*                                                                      *+********************************************************************* -}++{- Note [Acumulating parameter free variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We can use foldType to build an accumulating-parameter version of a+free-var finder, thus:++    fvs :: Type -> TyCoVarSet+    fvs ty = appEndo (foldType folder ty) emptyVarSet++Recall that+    foldType :: TyCoFolder env a -> env -> Type -> a++    newtype Endo a = Endo (a -> a)   -- In Data.Monoid+    instance Monoid a => Monoid (Endo a) where+       (Endo f) `mappend` (Endo g) = Endo (f.g)++    appEndo :: Endo a -> a -> a+    appEndo (Endo f) x = f x++So `mappend` for Endos is just function composition.++It's very important that, after optimisation, we end up with+* an arity-three function+* that is strict in the accumulator++   fvs env (TyVarTy v) acc+      | v `elemVarSet` env = acc+      | v `elemVarSet` acc = acc+      | otherwise          = acc `extendVarSet` v+   fvs env (AppTy t1 t2)   = fvs env t1 (fvs env t2 acc)+   ...++The "strict in the accumulator" part is to ensure that in the+AppTy equation we don't build a thunk for (fvs env t2 acc).++The optimiser does do all this, but not very robustly. It depends+critially on the basic arity-2 function not being exported, so that+all its calls are visibly to three arguments. This analysis is+done by the Call Arity pass.++TL;DR: check this regularly!+-}++runTyCoVars :: Endo TyCoVarSet -> TyCoVarSet+{-# INLINE runTyCoVars #-}+runTyCoVars f = appEndo f emptyVarSet++noView :: Type -> Maybe Type+noView _ = Nothing++{- *********************************************************************+*                                                                      *+          Deep free variables+          See Note [Shallow and deep free variables]+*                                                                      *+********************************************************************* -}+ tyCoVarsOfType :: Type -> TyCoVarSet--- See Note [Free variables of types]-tyCoVarsOfType ty = ty_co_vars_of_type ty emptyVarSet emptyVarSet+tyCoVarsOfType ty = runTyCoVars (deep_ty ty)+-- Alternative:+--   tyCoVarsOfType ty = closeOverKinds (shallowTyCoVarsOfType ty)  tyCoVarsOfTypes :: [Type] -> TyCoVarSet-tyCoVarsOfTypes tys = ty_co_vars_of_types tys emptyVarSet emptyVarSet+tyCoVarsOfTypes tys = runTyCoVars (deep_tys tys)+-- Alternative:+--   tyCoVarsOfTypes tys = closeOverKinds (shallowTyCoVarsOfTypes tys) -ty_co_vars_of_type :: Type -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_type (TyVarTy v) is acc-  | v `elemVarSet` is  = acc-  | v `elemVarSet` acc = acc-  | otherwise          = ty_co_vars_of_type (tyVarKind v)-                            emptyVarSet  -- See Note [Closing over free variable kinds]-                            (extendVarSet acc v)+tyCoVarsOfCo :: Coercion -> TyCoVarSet+-- See Note [Free variables of Coercions]+tyCoVarsOfCo co = runTyCoVars (deep_co co) -ty_co_vars_of_type (TyConApp _ tys)   is acc = ty_co_vars_of_types tys is acc-ty_co_vars_of_type (LitTy {})         _  acc = acc-ty_co_vars_of_type (AppTy fun arg)    is acc = ty_co_vars_of_type fun is (ty_co_vars_of_type arg is acc)-ty_co_vars_of_type (FunTy _ arg res)  is acc = ty_co_vars_of_type arg is (ty_co_vars_of_type res is acc)-ty_co_vars_of_type (ForAllTy (Bndr tv _) ty) is acc = ty_co_vars_of_type (varType tv) is $-                                                      ty_co_vars_of_type ty (extendVarSet is tv) acc-ty_co_vars_of_type (CastTy ty co)     is acc = ty_co_vars_of_type ty is (ty_co_vars_of_co co is acc)-ty_co_vars_of_type (CoercionTy co)    is acc = ty_co_vars_of_co co is acc+tyCoVarsOfCos :: [Coercion] -> TyCoVarSet+tyCoVarsOfCos cos = runTyCoVars (deep_cos cos) -ty_co_vars_of_types :: [Type] -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_types []       _  acc = acc-ty_co_vars_of_types (ty:tys) is acc = ty_co_vars_of_type ty is (ty_co_vars_of_types tys is acc)+deep_ty  :: Type       -> Endo TyCoVarSet+deep_tys :: [Type]     -> Endo TyCoVarSet+deep_co  :: Coercion   -> Endo TyCoVarSet+deep_cos :: [Coercion] -> Endo TyCoVarSet+(deep_ty, deep_tys, deep_co, deep_cos) = foldTyCo deepTcvFolder emptyVarSet -tyCoVarsOfCo :: Coercion -> TyCoVarSet+deepTcvFolder :: TyCoFolder TyCoVarSet (Endo TyCoVarSet)+deepTcvFolder = TyCoFolder { tcf_view = noView+                           , tcf_tyvar = do_tcv, tcf_covar = do_tcv+                           , tcf_hole  = do_hole, tcf_tycobinder = do_bndr }+  where+    do_tcv is v = Endo do_it+      where+        do_it acc | v `elemVarSet` is  = acc+                  | v `elemVarSet` acc = acc+                  | otherwise          = appEndo (deep_ty (varType v)) $+                                         acc `extendVarSet` v++    do_bndr is tcv _ = extendVarSet is tcv+    do_hole is hole  = do_tcv is (coHoleCoVar hole)+                       -- See Note [CoercionHoles and coercion free variables]+                       -- in TyCoRep++{- *********************************************************************+*                                                                      *+          Shallow free variables+          See Note [Shallow and deep free variables]+*                                                                      *+********************************************************************* -}+++shallowTyCoVarsOfType :: Type -> TyCoVarSet -- See Note [Free variables of types]-tyCoVarsOfCo co = ty_co_vars_of_co co emptyVarSet emptyVarSet+shallowTyCoVarsOfType ty = runTyCoVars (shallow_ty ty) -tyCoVarsOfCos :: [Coercion] -> TyCoVarSet-tyCoVarsOfCos cos = ty_co_vars_of_cos cos emptyVarSet emptyVarSet+shallowTyCoVarsOfTypes :: [Type] -> TyCoVarSet+shallowTyCoVarsOfTypes tys = runTyCoVars (shallow_tys tys) +shallowTyCoVarsOfCo :: Coercion -> TyCoVarSet+shallowTyCoVarsOfCo co = runTyCoVars (shallow_co co) -ty_co_vars_of_co :: Coercion -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_co (Refl ty)            is acc = ty_co_vars_of_type ty is acc-ty_co_vars_of_co (GRefl _ ty mco)     is acc = ty_co_vars_of_type ty is $-                                               ty_co_vars_of_mco mco is acc-ty_co_vars_of_co (TyConAppCo _ _ cos) is acc = ty_co_vars_of_cos cos is acc-ty_co_vars_of_co (AppCo co arg)       is acc = ty_co_vars_of_co co is $-                                               ty_co_vars_of_co arg is acc-ty_co_vars_of_co (ForAllCo tv kind_co co) is acc = ty_co_vars_of_co kind_co is $-                                                   ty_co_vars_of_co co (extendVarSet is tv) acc-ty_co_vars_of_co (FunCo _ co1 co2)    is acc = ty_co_vars_of_co co1 is $-                                               ty_co_vars_of_co co2 is acc-ty_co_vars_of_co (CoVarCo v)          is acc = ty_co_vars_of_co_var v is acc-ty_co_vars_of_co (HoleCo h)           is acc = ty_co_vars_of_co_var (coHoleCoVar h) is acc-    -- See Note [CoercionHoles and coercion free variables]-ty_co_vars_of_co (AxiomInstCo _ _ cos) is acc = ty_co_vars_of_cos cos is acc-ty_co_vars_of_co (UnivCo p _ t1 t2)    is acc = ty_co_vars_of_prov p is $-                                                ty_co_vars_of_type t1 is $-                                                ty_co_vars_of_type t2 is acc-ty_co_vars_of_co (SymCo co)          is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_co (TransCo co1 co2)   is acc = ty_co_vars_of_co co1 is $-                                              ty_co_vars_of_co co2 is acc-ty_co_vars_of_co (NthCo _ _ co)      is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_co (LRCo _ co)         is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_co (InstCo co arg)     is acc = ty_co_vars_of_co co is $-                                              ty_co_vars_of_co arg is acc-ty_co_vars_of_co (KindCo co)         is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_co (SubCo co)          is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_co (AxiomRuleCo _ cs)  is acc = ty_co_vars_of_cos cs is acc+shallowTyCoVarsOfCos :: [Coercion] -> TyCoVarSet+shallowTyCoVarsOfCos cos = runTyCoVars (shallow_cos cos) -ty_co_vars_of_mco :: MCoercion -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_mco MRefl    _is acc = acc-ty_co_vars_of_mco (MCo co) is  acc = ty_co_vars_of_co co is acc+-- | Returns free variables of types, including kind variables as+-- a non-deterministic set. For type synonyms it does /not/ expand the+-- synonym.+shallowTyCoVarsOfTyVarEnv :: TyVarEnv Type -> TyCoVarSet+-- See Note [Free variables of types]+shallowTyCoVarsOfTyVarEnv tys = shallowTyCoVarsOfTypes (nonDetEltsUFM tys)+  -- It's OK to use nonDetEltsUFM here because we immediately+  -- forget the ordering by returning a set -ty_co_vars_of_co_var :: CoVar -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_co_var v is acc-  | v `elemVarSet` is  = acc-  | v `elemVarSet` acc = acc-  | otherwise          = ty_co_vars_of_type (varType v)-                            emptyVarSet  -- See Note [Closing over free variable kinds]-                            (extendVarSet acc v)+shallowTyCoVarsOfCoVarEnv :: CoVarEnv Coercion -> TyCoVarSet+shallowTyCoVarsOfCoVarEnv cos = shallowTyCoVarsOfCos (nonDetEltsUFM cos)+  -- It's OK to use nonDetEltsUFM here because we immediately+  -- forget the ordering by returning a set -ty_co_vars_of_cos :: [Coercion] -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_cos []       _  acc = acc-ty_co_vars_of_cos (co:cos) is acc = ty_co_vars_of_co co is (ty_co_vars_of_cos cos is acc)+shallow_ty  :: Type       -> Endo TyCoVarSet+shallow_tys :: [Type]     -> Endo TyCoVarSet+shallow_co  :: Coercion   -> Endo TyCoVarSet+shallow_cos :: [Coercion] -> Endo TyCoVarSet+(shallow_ty, shallow_tys, shallow_co, shallow_cos) = foldTyCo shallowTcvFolder emptyVarSet -tyCoVarsOfProv :: UnivCoProvenance -> TyCoVarSet-tyCoVarsOfProv prov = ty_co_vars_of_prov prov emptyVarSet emptyVarSet+shallowTcvFolder :: TyCoFolder TyCoVarSet (Endo TyCoVarSet)+shallowTcvFolder = TyCoFolder { tcf_view = noView+                              , tcf_tyvar = do_tcv, tcf_covar = do_tcv+                              , tcf_hole  = do_hole, tcf_tycobinder = do_bndr }+  where+    do_tcv is v = Endo do_it+      where+        do_it acc | v `elemVarSet` is  = acc+                  | v `elemVarSet` acc = acc+                  | otherwise          = acc `extendVarSet` v -ty_co_vars_of_prov :: UnivCoProvenance -> TyCoVarSet -> TyCoVarSet -> TyCoVarSet-ty_co_vars_of_prov (PhantomProv co)    is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_prov (ProofIrrelProv co) is acc = ty_co_vars_of_co co is acc-ty_co_vars_of_prov UnsafeCoerceProv    _  acc = acc-ty_co_vars_of_prov (PluginProv _)      _  acc = acc+    do_bndr is tcv _ = extendVarSet is tcv+    do_hole _ _  = mempty   -- Ignore coercion holes --- | Generates an in-scope set from the free variables in a list of types--- and a list of coercions-mkTyCoInScopeSet :: [Type] -> [Coercion] -> InScopeSet-mkTyCoInScopeSet tys cos-  = mkInScopeSet (ty_co_vars_of_types tys emptyVarSet $-                  ty_co_vars_of_cos   cos emptyVarSet emptyVarSet) +{- *********************************************************************+*                                                                      *+          Free coercion variables+*                                                                      *+********************************************************************* -}+++{- Note [Finding free coercion varibles]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Here we are only interested in the free /coercion/ variables.+We can achieve this through a slightly differnet TyCo folder.++Notice that we look deeply, into kinds.++See #14880.+-}++coVarsOfType  :: Type       -> CoVarSet+coVarsOfTypes :: [Type]     -> CoVarSet+coVarsOfCo    :: Coercion   -> CoVarSet+coVarsOfCos   :: [Coercion] -> CoVarSet++coVarsOfType  ty  = runTyCoVars (deep_cv_ty ty)+coVarsOfTypes tys = runTyCoVars (deep_cv_tys tys)+coVarsOfCo    co  = runTyCoVars (deep_cv_co co)+coVarsOfCos   cos = runTyCoVars (deep_cv_cos cos)++deep_cv_ty  :: Type       -> Endo CoVarSet+deep_cv_tys :: [Type]     -> Endo CoVarSet+deep_cv_co  :: Coercion   -> Endo CoVarSet+deep_cv_cos :: [Coercion] -> Endo CoVarSet+(deep_cv_ty, deep_cv_tys, deep_cv_co, deep_cv_cos) = foldTyCo deepCoVarFolder emptyVarSet++deepCoVarFolder :: TyCoFolder TyCoVarSet (Endo CoVarSet)+deepCoVarFolder = TyCoFolder { tcf_view = noView+                             , tcf_tyvar = do_tyvar, tcf_covar = do_covar+                             , tcf_hole  = do_hole, tcf_tycobinder = do_bndr }+  where+    do_tyvar _ _  = mempty+      -- This do_tyvar means we won't see any CoVars in this+      -- TyVar's kind.   This may be wrong; but it's the way it's+      -- always been.  And its awkward to change, because+      -- the tyvar won't end up in the accumulator, so+      -- we'd look repeatedly.  Blargh.++    do_covar is v = Endo do_it+      where+        do_it acc | v `elemVarSet` is  = acc+                  | v `elemVarSet` acc = acc+                  | otherwise          = appEndo (deep_cv_ty (varType v)) $+                                         acc `extendVarSet` v++    do_bndr is tcv _ = extendVarSet is tcv+    do_hole is hole  = do_covar is (coHoleCoVar hole)+                       -- See Note [CoercionHoles and coercion free variables]+                       -- in TyCoRep+++{- *********************************************************************+*                                                                      *+          Closing over kinds+*                                                                      *+********************************************************************* -}++------------- Closing over kinds -----------------++closeOverKinds :: TyCoVarSet -> TyCoVarSet+-- For each element of the input set,+-- add the deep free variables of its kind+closeOverKinds vs = nonDetFoldVarSet do_one vs vs+  where+    do_one v acc = appEndo (deep_ty (varType v)) acc++{- --------------- Alternative version 1 (using FV) ------------+closeOverKinds = fvVarSet . closeOverKindsFV . nonDetEltsUniqSet+-}++{- ---------------- Alternative version 2 -------------++-- | Add the kind variables free in the kinds of the tyvars in the given set.+-- Returns a non-deterministic set.+closeOverKinds :: TyCoVarSet -> TyCoVarSet+closeOverKinds vs+   = go vs vs+  where+    go :: VarSet   -- Work list+       -> VarSet   -- Accumulator, always a superset of wl+       -> VarSet+    go wl acc+      | isEmptyVarSet wl = acc+      | otherwise        = go wl_kvs (acc `unionVarSet` wl_kvs)+      where+        k v inner_acc = ty_co_vars_of_type (varType v) acc inner_acc+        wl_kvs = nonDetFoldVarSet k emptyVarSet wl+        -- wl_kvs = union of shallow free vars of the kinds of wl+        --          but don't bother to collect vars in acc++-}++{- ---------------- Alternative version 3 -------------+-- | Add the kind variables free in the kinds of the tyvars in the given set.+-- Returns a non-deterministic set.+closeOverKinds :: TyVarSet -> TyVarSet+closeOverKinds vs = close_over_kinds vs emptyVarSet+++close_over_kinds :: TyVarSet  -- Work list+                 -> TyVarSet  -- Accumulator+                 -> TyVarSet+-- Precondition: in any call (close_over_kinds wl acc)+--  for every tv in acc, the shallow kind-vars of tv+--  are either in the work list wl, or in acc+-- Postcondition: result is the deep free vars of (wl `union` acc)+close_over_kinds wl acc+  = nonDetFoldVarSet do_one acc wl+  where+    do_one :: Var -> TyVarSet -> TyVarSet+    -- (do_one v acc) adds v and its deep free-vars to acc+    do_one v acc | v `elemVarSet` acc+                 = acc+                 | otherwise+                 = close_over_kinds (shallowTyCoVarsOfType (varType v)) $+                   acc `extendVarSet` v+-}+++{- *********************************************************************+*                                                                      *+          The FV versions return deterministic results+*                                                                      *+********************************************************************* -}++-- | Given a list of tyvars returns a deterministic FV computation that+-- returns the given tyvars with the kind variables free in the kinds of the+-- given tyvars.+closeOverKindsFV :: [TyVar] -> FV+closeOverKindsFV tvs =+  mapUnionFV (tyCoFVsOfType . tyVarKind) tvs `unionFV` mkFVs tvs++-- | Add the kind variables free in the kinds of the tyvars in the given set.+-- Returns a deterministically ordered list.+closeOverKindsList :: [TyVar] -> [TyVar]+closeOverKindsList tvs = fvVarList $ closeOverKindsFV tvs++-- | Add the kind variables free in the kinds of the tyvars in the given set.+-- Returns a deterministic set.+closeOverKindsDSet :: DTyVarSet -> DTyVarSet+closeOverKindsDSet = fvDVarSet . closeOverKindsFV . dVarSetElems+ -- | `tyCoFVsOfType` that returns free variables of a type in a deterministic -- set. For explanation of why using `VarSet` is not deterministic see -- Note [Deterministic FV] in FV.@@ -282,15 +536,6 @@ tyCoVarsOfTypeList ty = fvVarList $ tyCoFVsOfType ty  -- | Returns free variables of types, including kind variables as--- a non-deterministic set. For type synonyms it does /not/ expand the--- synonym.-tyCoVarsOfTypesSet :: TyVarEnv Type -> TyCoVarSet--- See Note [Free variables of types]-tyCoVarsOfTypesSet tys = tyCoVarsOfTypes $ nonDetEltsUFM tys-  -- It's OK to use nonDetEltsUFM here because we immediately forget the-  -- ordering by returning a set---- | Returns free variables of types, including kind variables as -- a deterministic set. For type synonyms it does /not/ expand the -- synonym. tyCoVarsOfTypesDSet :: [Type] -> DTyCoVarSet@@ -304,75 +549,6 @@ -- See Note [Free variables of types] tyCoVarsOfTypesList tys = fvVarList $ tyCoFVsOfTypes tys -{--************************************************************************-*                                                                      *-          The "exact" free variables of a type-*                                                                      *-************************************************************************--Note [Silly type synonym]-~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-  type T a = Int-What are the free tyvars of (T x)?  Empty, of course!--exactTyCoVarsOfType is used by the type checker to figure out exactly-which type variables are mentioned in a type.  It only matters-occasionally -- see the calls to exactTyCoVarsOfType.--}--exactTyCoVarsOfType :: Type -> TyCoVarSet--- Find the free type variables (of any kind)--- but *expand* type synonyms.  See Note [Silly type synonym] above.-exactTyCoVarsOfType ty-  = go ty-  where-    go ty | Just ty' <- tcView ty = go ty'  -- This is the key line-    go (TyVarTy tv)         = goVar tv-    go (TyConApp _ tys)     = exactTyCoVarsOfTypes tys-    go (LitTy {})           = emptyVarSet-    go (AppTy fun arg)      = go fun `unionVarSet` go arg-    go (FunTy _ arg res)    = go arg `unionVarSet` go res-    go (ForAllTy bndr ty)   = delBinderVar (go ty) bndr `unionVarSet` go (binderType bndr)-    go (CastTy ty co)       = go ty `unionVarSet` goCo co-    go (CoercionTy co)      = goCo co--    goMCo MRefl    = emptyVarSet-    goMCo (MCo co) = goCo co--    goCo (Refl ty)            = go ty-    goCo (GRefl _ ty mco)     = go ty `unionVarSet` goMCo mco-    goCo (TyConAppCo _ _ args)= goCos args-    goCo (AppCo co arg)     = goCo co `unionVarSet` goCo arg-    goCo (ForAllCo tv k_co co)-      = goCo co `delVarSet` tv `unionVarSet` goCo k_co-    goCo (FunCo _ co1 co2)   = goCo co1 `unionVarSet` goCo co2-    goCo (CoVarCo v)         = goVar v-    goCo (HoleCo h)          = goVar (coHoleCoVar h)-    goCo (AxiomInstCo _ _ args) = goCos args-    goCo (UnivCo p _ t1 t2)  = goProv p `unionVarSet` go t1 `unionVarSet` go t2-    goCo (SymCo co)          = goCo co-    goCo (TransCo co1 co2)   = goCo co1 `unionVarSet` goCo co2-    goCo (NthCo _ _ co)      = goCo co-    goCo (LRCo _ co)         = goCo co-    goCo (InstCo co arg)     = goCo co `unionVarSet` goCo arg-    goCo (KindCo co)         = goCo co-    goCo (SubCo co)          = goCo co-    goCo (AxiomRuleCo _ c)   = goCos c--    goCos cos = foldr (unionVarSet . goCo) emptyVarSet cos--    goProv UnsafeCoerceProv     = emptyVarSet-    goProv (PhantomProv kco)    = goCo kco-    goProv (ProofIrrelProv kco) = goCo kco-    goProv (PluginProv _)       = emptyVarSet--    goVar v = unitVarSet v `unionVarSet` go (varType v)--exactTyCoVarsOfTypes :: [Type] -> TyVarSet-exactTyCoVarsOfTypes tys = mapUnionVarSet exactTyCoVarsOfType tys- -- | The worker for `tyCoFVsOfType` and `tyCoFVsOfTypeList`. -- The previous implementation used `unionVarSet` which is O(n+m) and can -- make the function quadratic.@@ -429,11 +605,6 @@ tyCoFVsOfMCo MRefl    = emptyFV tyCoFVsOfMCo (MCo co) = tyCoFVsOfCo co -tyCoVarsOfCosSet :: CoVarEnv Coercion -> TyCoVarSet-tyCoVarsOfCosSet cos = tyCoVarsOfCos $ nonDetEltsUFM cos-  -- It's OK to use nonDetEltsUFM here because we immediately forget the-  -- ordering by returning a set- tyCoFVsOfCo :: Coercion -> FV -- Extracts type and coercion variables from a coercion -- See Note [Free variables of types]@@ -471,7 +642,6 @@   = (unitFV v `unionFV` tyCoFVsOfType (varType v)) fv_cand in_scope acc  tyCoFVsOfProv :: UnivCoProvenance -> FV-tyCoFVsOfProv UnsafeCoerceProv    fv_cand in_scope acc = emptyFV fv_cand in_scope acc tyCoFVsOfProv (PhantomProv co)    fv_cand in_scope acc = tyCoFVsOfCo co fv_cand in_scope acc tyCoFVsOfProv (ProofIrrelProv co) fv_cand in_scope acc = tyCoFVsOfCo co fv_cand in_scope acc tyCoFVsOfProv (PluginProv _)      fv_cand in_scope acc = emptyFV fv_cand in_scope acc@@ -481,41 +651,6 @@ tyCoFVsOfCos (co:cos) fv_cand in_scope acc = (tyCoFVsOfCo co `unionFV` tyCoFVsOfCos cos) fv_cand in_scope acc  -------------- Extracting the CoVars of a type or coercion -------------{---Note [CoVarsOfX and the InterestingVarFun]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--The coVarsOfType, coVarsOfTypes, coVarsOfCo, and coVarsOfCos functions are-implemented in terms of the respective FV equivalents (tyCoFVsOf...), rather-than the VarSet-based flavors (tyCoVarsOf...), despite the performance-considerations outlined in Note [Free variables of types].--This is because FV includes the InterestingVarFun, which is useful here,-because we can cleverly use it to restrict our calculations to CoVars - this-is what getCoVarSet achieves.--See #14880.---}--getCoVarSet :: FV -> CoVarSet-getCoVarSet fv = snd (fv isCoVar emptyVarSet ([], emptyVarSet))--coVarsOfType :: Type -> CoVarSet-coVarsOfType ty = getCoVarSet (tyCoFVsOfType ty)--coVarsOfTypes :: [Type] -> TyCoVarSet-coVarsOfTypes tys = getCoVarSet (tyCoFVsOfTypes tys)--coVarsOfCo :: Coercion -> CoVarSet-coVarsOfCo co = getCoVarSet (tyCoFVsOfCo co)--coVarsOfCos :: [Coercion] -> CoVarSet-coVarsOfCos cos = getCoVarSet (tyCoFVsOfCos cos)- ----- Whether a covar is /Almost Devoid/ in a type or coercion ----  -- | Given a covar and a coercion, returns True if covar is almost devoid in@@ -578,7 +713,6 @@   = almost_devoid_co_var_of_co co cv almost_devoid_co_var_of_prov (ProofIrrelProv co) cv   = almost_devoid_co_var_of_co co cv-almost_devoid_co_var_of_prov UnsafeCoerceProv _ = True almost_devoid_co_var_of_prov (PluginProv _) _ = True  almost_devoid_co_var_of_type :: Type -> CoVar -> Bool@@ -607,8 +741,14 @@   = almost_devoid_co_var_of_type ty cv   && almost_devoid_co_var_of_types tys cv -------------- Injective free vars ----------------- ++{- *********************************************************************+*                                                                      *+                 Injective free vars+*                                                                      *+********************************************************************* -}+ -- | Returns the free variables of a 'Type' that are in injective positions. -- Specifically, it finds the free variables while: --@@ -675,7 +815,13 @@ injectiveVarsOfTypes look_under_tfs = mapUnionFV (injectiveVarsOfType look_under_tfs)  -------------- Invisible vars -----------------+{- *********************************************************************+*                                                                      *+                 Invisible vars+*                                                                      *+********************************************************************* -}++ -- | Returns the set of variables that are used invisibly anywhere within -- the given type. A variable will be included even if it is used both visibly -- and invisibly. An invisible use site includes:@@ -705,68 +851,44 @@ invisibleVarsOfTypes = mapUnionFV invisibleVarsOfType  -------------- No free vars -----------------+{- *********************************************************************+*                                                                      *+                 No free vars+*                                                                      *+********************************************************************* -} --- | Returns True if this type has no free variables. Should be the same as--- isEmptyVarSet . tyCoVarsOfType, but faster in the non-forall case.-noFreeVarsOfType :: Type -> Bool-noFreeVarsOfType (TyVarTy _)      = False-noFreeVarsOfType (AppTy t1 t2)    = noFreeVarsOfType t1 && noFreeVarsOfType t2-noFreeVarsOfType (TyConApp _ tys) = all noFreeVarsOfType tys-noFreeVarsOfType ty@(ForAllTy {}) = isEmptyVarSet (tyCoVarsOfType ty)-noFreeVarsOfType (FunTy _ t1 t2)  = noFreeVarsOfType t1 && noFreeVarsOfType t2-noFreeVarsOfType (LitTy _)        = True-noFreeVarsOfType (CastTy ty co)   = noFreeVarsOfType ty && noFreeVarsOfCo co-noFreeVarsOfType (CoercionTy co)  = noFreeVarsOfCo co+nfvFolder :: TyCoFolder TyCoVarSet DM.All+nfvFolder = TyCoFolder { tcf_view = noView+                       , tcf_tyvar = do_tcv, tcf_covar = do_tcv+                       , tcf_hole = do_hole, tcf_tycobinder = do_bndr }+  where+    do_tcv is tv = All (tv `elemVarSet` is)+    do_hole _ _  = All True    -- I'm unsure; probably never happens+    do_bndr is tv _ = is `extendVarSet` tv -noFreeVarsOfMCo :: MCoercion -> Bool-noFreeVarsOfMCo MRefl    = True-noFreeVarsOfMCo (MCo co) = noFreeVarsOfCo co+nfv_ty  :: Type       -> DM.All+nfv_tys :: [Type]     -> DM.All+nfv_co  :: Coercion   -> DM.All+(nfv_ty, nfv_tys, nfv_co, _) = foldTyCo nfvFolder emptyVarSet +noFreeVarsOfType :: Type -> Bool+noFreeVarsOfType ty = DM.getAll (nfv_ty ty)+ noFreeVarsOfTypes :: [Type] -> Bool-noFreeVarsOfTypes = all noFreeVarsOfType+noFreeVarsOfTypes tys = DM.getAll (nfv_tys tys) --- | Returns True if this coercion has no free variables. Should be the same as--- isEmptyVarSet . tyCoVarsOfCo, but faster in the non-forall case. noFreeVarsOfCo :: Coercion -> Bool-noFreeVarsOfCo (Refl ty)              = noFreeVarsOfType ty-noFreeVarsOfCo (GRefl _ ty co)        = noFreeVarsOfType ty && noFreeVarsOfMCo co-noFreeVarsOfCo (TyConAppCo _ _ args)  = all noFreeVarsOfCo args-noFreeVarsOfCo (AppCo c1 c2)          = noFreeVarsOfCo c1 && noFreeVarsOfCo c2-noFreeVarsOfCo co@(ForAllCo {})       = isEmptyVarSet (tyCoVarsOfCo co)-noFreeVarsOfCo (FunCo _ c1 c2)        = noFreeVarsOfCo c1 && noFreeVarsOfCo c2-noFreeVarsOfCo (CoVarCo _)            = False-noFreeVarsOfCo (HoleCo {})            = True    -- I'm unsure; probably never happens-noFreeVarsOfCo (AxiomInstCo _ _ args) = all noFreeVarsOfCo args-noFreeVarsOfCo (UnivCo p _ t1 t2)     = noFreeVarsOfProv p &&-                                        noFreeVarsOfType t1 &&-                                        noFreeVarsOfType t2-noFreeVarsOfCo (SymCo co)             = noFreeVarsOfCo co-noFreeVarsOfCo (TransCo co1 co2)      = noFreeVarsOfCo co1 && noFreeVarsOfCo co2-noFreeVarsOfCo (NthCo _ _ co)         = noFreeVarsOfCo co-noFreeVarsOfCo (LRCo _ co)            = noFreeVarsOfCo co-noFreeVarsOfCo (InstCo co1 co2)       = noFreeVarsOfCo co1 && noFreeVarsOfCo co2-noFreeVarsOfCo (KindCo co)            = noFreeVarsOfCo co-noFreeVarsOfCo (SubCo co)             = noFreeVarsOfCo co-noFreeVarsOfCo (AxiomRuleCo _ cs)     = all noFreeVarsOfCo cs+noFreeVarsOfCo co = getAll (nfv_co co) --- | Returns True if this UnivCoProv has no free variables. Should be the same as--- isEmptyVarSet . tyCoVarsOfProv, but faster in the non-forall case.-noFreeVarsOfProv :: UnivCoProvenance -> Bool-noFreeVarsOfProv UnsafeCoerceProv    = True-noFreeVarsOfProv (PhantomProv co)    = noFreeVarsOfCo co-noFreeVarsOfProv (ProofIrrelProv co) = noFreeVarsOfCo co-noFreeVarsOfProv (PluginProv {})     = True -{--%************************************************************************-%*                                                                      *-         Well-scoped tyvars+{- ********************************************************************* *                                                                      *-************************************************************************+                 scopedSort+*                                                                      *+********************************************************************* -} -Note [ScopedSort]-~~~~~~~~~~~~~~~~~+{- Note [ScopedSort]+~~~~~~~~~~~~~~~~~~~~ Consider    foo :: Proxy a -> Proxy (b :: k) -> Proxy (a :: k2) -> ()@@ -859,3 +981,4 @@ -- | Get the free vars of types in scoped order tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar] tyCoVarsOfTypesWellScoped = scopedSort . tyCoVarsOfTypesList+

compiler/types/TyCoPpr.hs view

@@ -49,8 +49,6 @@ import VarSet import VarEnv -import DynFlags   ( gopt_set,-                    GeneralFlag(Opt_PrintExplicitKinds, Opt_PrintExplicitRuntimeReps) ) import Outputable import BasicTypes ( PprPrec(..), topPrec, sigPrec, opPrec                   , funPrec, appPrec, maybeParen )@@ -78,7 +76,7 @@ -------------------------------------------------------- -- When pretty-printing types, we convert to IfaceType, --   and pretty-print that.--- See Note [Pretty printing via Iface syntax] in PprTyThing+-- See Note [Pretty printing via Iface syntax] in GHC.Core.Ppr.TyThing --------------------------------------------------------  pprType, pprParendType, pprTidiedType :: Type -> SDoc@@ -318,14 +316,14 @@ -- See @Note [Kind arguments in error messages]@ in TcErrors. pprWithExplicitKindsWhen :: Bool -> SDoc -> SDoc pprWithExplicitKindsWhen b-  = updSDocDynFlags $ \dflags ->-      if b then gopt_set dflags Opt_PrintExplicitKinds-           else dflags+  = updSDocContext $ \ctx ->+      if b then ctx { sdocPrintExplicitKinds = True }+           else ctx  -- | This variant preserves any use of TYPE in a type, effectively -- locally setting -fprint-explicit-runtime-reps. pprWithTYPE :: Type -> SDoc-pprWithTYPE ty = updSDocDynFlags (flip gopt_set Opt_PrintExplicitRuntimeReps) $+pprWithTYPE ty = updSDocContext (\ctx -> ctx { sdocPrintExplicitRuntimeReps = True }) $                  ppr ty  -- | Pretty prints a 'TyCon', using the family instance in case of a

compiler/types/TyCoRep.hs view

@@ -61,6 +61,9 @@         -- * Functions over coercions         pickLR, +        -- ** Analyzing types+        TyCoFolder(..), foldTyCo,+         -- * Sizes         typeSize, coercionSize, provSize     ) where@@ -136,7 +139,7 @@   getName (AConLike cl) = conLikeName cl  pprShortTyThing :: TyThing -> SDoc--- c.f. PprTyThing.pprTyThing, which prints all the details+-- c.f. GHC.Core.Ppr.TyThing.pprTyThing, which prints all the details pprShortTyThing thing   = pprTyThingCategory thing <+> quotes (ppr (getName thing)) @@ -167,7 +170,7 @@ type Kind = Type  -- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs+-- See Note [GHC Formalism] in GHC.Core.Lint data Type   -- See Note [Non-trivial definitional equality]   = TyVarTy Var -- ^ Vanilla type or kind variable (*never* a coercion variable)@@ -812,10 +815,8 @@  Specified: a list of Specified binders is written between `forall` and `.`:                const :: forall a b. a -> b -> a - Inferred:  with -fprint-explicit-foralls, Inferred binders are written-            in braces:+ Inferred: like Specified, but every binder is written in braces:                f :: forall {k} (a:k). S k a -> Int-            Otherwise, they are printed like Specified binders.   Required: binders are put between `forall` and `->`:               T :: forall k -> *@@ -962,7 +963,7 @@ -- of two types.  -- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs+-- See Note [GHC Formalism] in GHC.Core.Lint data Coercion   -- Each constructor has a "role signature", indicating the way roles are   -- propagated through coercions.@@ -1450,8 +1451,7 @@ %************************************************************************  A UnivCo is a coercion whose proof does not directly express its role-and kind (indeed for some UnivCos, like UnsafeCoerceProv, there /is/-no proof).+and kind (indeed for some UnivCos, like PluginProv, there /is/ no proof).  The different kinds of UnivCo are described by UnivCoProvenance.  Really each is entirely separate, but they all share the need to represent their@@ -1468,9 +1468,7 @@ -- that they don't tell you what types they coercion between. (That info -- is in the 'UnivCo' constructor of 'Coercion'. data UnivCoProvenance-  = UnsafeCoerceProv   -- ^ From @unsafeCoerce#@. These are unsound.--  | PhantomProv KindCoercion -- ^ See Note [Phantom coercions]. Only in Phantom+  = PhantomProv KindCoercion -- ^ See Note [Phantom coercions]. Only in Phantom                              -- roled coercions    | ProofIrrelProv KindCoercion  -- ^ From the fact that any two coercions are@@ -1483,7 +1481,6 @@   deriving Data.Data  instance Outputable UnivCoProvenance where-  ppr UnsafeCoerceProv   = text "(unsafeCoerce#)"   ppr (PhantomProv _)    = text "(phantom)"   ppr (ProofIrrelProv _) = text "(proof irrel.)"   ppr (PluginProv str)   = parens (text "plugin" <+> brackets (text str))@@ -1635,6 +1632,168 @@  {- ********************************************************************* *                                                                      *+                foldType  and   foldCoercion+*                                                                      *+********************************************************************* -}++{- Note [foldType]+~~~~~~~~~~~~~~~~~~+foldType is a bit more powerful than perhaps it looks:++* You can fold with an accumulating parameter, via+     TyCoFolder env (Endo a)+  Recall newtype Endo a = Endo (a->a)++* You can fold monadically with a monad M, via+     TyCoFolder env (M a)+  provided you have+     instance ..  => Monoid (M a)++Note [mapType vs foldType]+~~~~~~~~~~~~~~~~~~~~~~~~~~+We define foldType here, but mapType in module Type. Why?++* foldType is used in TyCoFVs for finding free variables.+  It's a very simple function that analyses a type,+  but does not construct one.++* mapType constructs new types, and so it needs to call+  the "smart constructors", mkAppTy, mkCastTy, and so on.+  These are sophisticated functions, and can't be defined+  here in TyCoRep.++Note [Specialising foldType]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We inline foldType at every call site (there are not many), so that it+becomes specialised for the particular monoid *and* TyCoFolder at+that site.  This is just for efficiency, but walking over types is+done a *lot* in GHC, so worth optimising.++We were worried that+    TyCoFolder env (Endo a)+might not eta-expand.  Recall newtype Endo a = Endo (a->a).++In particular, given+   fvs :: Type -> TyCoVarSet+   fvs ty = appEndo (foldType tcf emptyVarSet ty) emptyVarSet++   tcf :: TyCoFolder enf (Endo a)+   tcf = TyCoFolder { tcf_tyvar = do_tv, ... }+      where+        do_tvs is tv = Endo do_it+           where+             do_it acc | tv `elemVarSet` is  = acc+                       | tv `elemVarSet` acc = acc+                       | otherwise = acc `extendVarSet` tv+++we want to end up with+   fvs ty = go emptyVarSet ty emptyVarSet+     where+       go env (TyVarTy tv) acc = acc `extendVarSet` tv+       ..etc..++And indeed this happens.+  - Selections from 'tcf' are done at compile time+  - 'go' is nicely eta-expanded.++We were also worried about+   deep_fvs :: Type -> TyCoVarSet+   deep_fvs ty = appEndo (foldType deep_tcf emptyVarSet ty) emptyVarSet++   deep_tcf :: TyCoFolder enf (Endo a)+   deep_tcf = TyCoFolder { tcf_tyvar = do_tv, ... }+      where+        do_tvs is tv = Endo do_it+           where+             do_it acc | tv `elemVarSet` is  = acc+                       | tv `elemVarSet` acc = acc+                       | otherwise = deep_fvs (varType tv)+                                     `unionVarSet` acc+                                     `extendVarSet` tv++Here deep_fvs and deep_tcf are mutually recursive, unlike fvs and tcf.+But, amazingly, we get good code here too. GHC is careful not to makr+TyCoFolder data constructor for deep_tcf as a loop breaker, so the+record selections still cancel.  And eta expansion still happens too.+-}++data TyCoFolder env a+  = TyCoFolder+      { tcf_view  :: Type -> Maybe Type   -- Optional "view" function+                                          -- E.g. expand synonyms+      , tcf_tyvar :: env -> TyVar -> a+      , tcf_covar :: env -> CoVar -> a+      , tcf_hole  :: env -> CoercionHole -> a+          -- ^ What to do with coercion holes.+          -- See Note [Coercion holes] in TyCoRep.++      , tcf_tycobinder :: env -> TyCoVar -> ArgFlag -> env+          -- ^ The returned env is used in the extended scope+      }++{-# INLINE foldTyCo  #-}  -- See Note [Specialising foldType]+foldTyCo :: Monoid a => TyCoFolder env a -> env+         -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)+foldTyCo (TyCoFolder { tcf_view       = view+                     , tcf_tyvar      = tyvar+                     , tcf_tycobinder = tycobinder+                     , tcf_covar      = covar+                     , tcf_hole       = cohole }) env+  = (go_ty env, go_tys env, go_co env, go_cos env)+  where+    go_ty env ty | Just ty' <- view ty = go_ty env ty'+    go_ty env (TyVarTy tv)      = tyvar env tv+    go_ty env (AppTy t1 t2)     = go_ty env t1 `mappend` go_ty env t2+    go_ty _   (LitTy {})        = mempty+    go_ty env (CastTy ty co)    = go_ty env ty `mappend` go_co env co+    go_ty env (CoercionTy co)   = go_co env co+    go_ty env (FunTy _ arg res) = go_ty env arg `mappend` go_ty env res+    go_ty env (TyConApp _ tys)  = go_tys env tys+    go_ty env (ForAllTy (Bndr tv vis) inner)+      = let !env' = tycobinder env tv vis  -- Avoid building a thunk here+        in go_ty env (varType tv) `mappend` go_ty env' inner++    -- Explicit recursion becuase using foldr builds a local+    -- loop (with env free) and I'm not confident it'll be+    -- lambda lifted in the end+    go_tys _   []     = mempty+    go_tys env (t:ts) = go_ty env t `mappend` go_tys env ts++    go_cos _   []     = mempty+    go_cos env (c:cs) = go_co env c `mappend` go_cos env cs++    go_co env (Refl ty)               = go_ty env ty+    go_co env (GRefl _ ty MRefl)      = go_ty env ty+    go_co env (GRefl _ ty (MCo co))   = go_ty env ty `mappend` go_co env co+    go_co env (TyConAppCo _ _ args)   = go_cos env args+    go_co env (AppCo c1 c2)           = go_co env c1 `mappend` go_co env c2+    go_co env (FunCo _ c1 c2)         = go_co env c1 `mappend` go_co env c2+    go_co env (CoVarCo cv)            = covar env cv+    go_co env (AxiomInstCo _ _ args)  = go_cos env args+    go_co env (HoleCo hole)           = cohole env hole+    go_co env (UnivCo p _ t1 t2)      = go_prov env p `mappend` go_ty env t1+                                                      `mappend` go_ty env t2+    go_co env (SymCo co)              = go_co env co+    go_co env (TransCo c1 c2)         = go_co env c1 `mappend` go_co env c2+    go_co env (AxiomRuleCo _ cos)     = go_cos env cos+    go_co env (NthCo _ _ co)          = go_co env co+    go_co env (LRCo _ co)             = go_co env co+    go_co env (InstCo co arg)         = go_co env co `mappend` go_co env arg+    go_co env (KindCo co)             = go_co env co+    go_co env (SubCo co)              = go_co env co+    go_co env (ForAllCo tv kind_co co)+      = go_co env kind_co `mappend` go_ty env (varType tv)+                          `mappend` go_co env' co+      where+        env' = tycobinder env tv Inferred++    go_prov env (PhantomProv co)    = go_co env co+    go_prov env (ProofIrrelProv co) = go_co env co+    go_prov _   (PluginProv _)      = mempty++{- *********************************************************************+*                                                                      *                    typeSize, coercionSize *                                                                      * ********************************************************************* -}@@ -1684,7 +1843,6 @@ coercionSize (AxiomRuleCo _ cs)  = 1 + sum (map coercionSize cs)  provSize :: UnivCoProvenance -> Int-provSize UnsafeCoerceProv    = 1 provSize (PhantomProv co)    = 1 + coercionSize co provSize (ProofIrrelProv co) = 1 + coercionSize co provSize (PluginProv _)      = 1

compiler/types/TyCoSubst.hs view

@@ -26,7 +26,7 @@         extendTvSubst, extendTvSubstBinderAndInScope, extendTvSubstWithClone,         extendTvSubstList, extendTvSubstAndInScope,         extendTCvSubstList,-        unionTCvSubst, zipTyEnv, zipCoEnv, mkTyCoInScopeSet,+        unionTCvSubst, zipTyEnv, zipCoEnv,         zipTvSubst, zipCvSubst,         zipTCvSubst,         mkTvSubstPrs,@@ -80,7 +80,7 @@ import UniqSet import Outputable -import Data.List+import Data.List (mapAccumL)  {- %************************************************************************@@ -135,7 +135,7 @@   (SIa) The free vars of the range of the substitution   (SIb) The free vars of ty minus the domain of the substitution -The same rules apply to other substitutions (notably CoreSubst.Subst)+The same rules apply to other substitutions (notably GHC.Core.Subst.Subst)  * Reason for (SIa). Consider       substTy [a :-> Maybe b] (forall b. b->a)@@ -283,8 +283,8 @@ getTCvSubstRangeFVs (TCvSubst _ tenv cenv)     = unionVarSet tenvFVs cenvFVs   where-    tenvFVs = tyCoVarsOfTypesSet tenv-    cenvFVs = tyCoVarsOfCosSet cenv+    tenvFVs = shallowTyCoVarsOfTyVarEnv tenv+    cenvFVs = shallowTyCoVarsOfCoVarEnv cenv  isInScope :: Var -> TCvSubst -> Bool isInScope v (TCvSubst in_scope _ _) = v `elemInScopeSet` in_scope@@ -395,7 +395,7 @@ -- environment. No CoVars, please! zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> TCvSubst zipTvSubst tvs tys-  = mkTvSubst (mkInScopeSet (tyCoVarsOfTypes tys)) tenv+  = mkTvSubst (mkInScopeSet (shallowTyCoVarsOfTypes tys)) tenv   where     tenv = zipTyEnv tvs tys @@ -403,13 +403,14 @@ -- environment.  No TyVars, please! zipCvSubst :: HasDebugCallStack => [CoVar] -> [Coercion] -> TCvSubst zipCvSubst cvs cos-  = TCvSubst (mkInScopeSet (tyCoVarsOfCos cos)) emptyTvSubstEnv cenv+  = TCvSubst (mkInScopeSet (shallowTyCoVarsOfCos cos)) emptyTvSubstEnv cenv   where     cenv = zipCoEnv cvs cos  zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> TCvSubst zipTCvSubst tcvs tys-  = zip_tcvsubst tcvs tys (mkEmptyTCvSubst $ mkInScopeSet (tyCoVarsOfTypes tys))+  = zip_tcvsubst tcvs tys $+    mkEmptyTCvSubst $ mkInScopeSet $ shallowTyCoVarsOfTypes tys   where zip_tcvsubst :: [TyCoVar] -> [Type] -> TCvSubst -> TCvSubst         zip_tcvsubst (tv:tvs) (ty:tys) subst           = zip_tcvsubst tvs tys (extendTCvSubst subst tv ty)@@ -424,7 +425,7 @@     ASSERT2( onlyTyVarsAndNoCoercionTy, text "prs" <+> ppr prs )     mkTvSubst in_scope tenv   where tenv = mkVarEnv prs-        in_scope = mkInScopeSet $ tyCoVarsOfTypes $ map snd prs+        in_scope = mkInScopeSet $ shallowTyCoVarsOfTypes $ map snd prs         onlyTyVarsAndNoCoercionTy =           and [ isTyVar tv && not (isCoercionTy ty)               | (tv, ty) <- prs ]@@ -618,8 +619,8 @@   (tenvFVs `varSetInScope` in_scope) &&   (cenvFVs `varSetInScope` in_scope)   where-  tenvFVs = tyCoVarsOfTypesSet tenv-  cenvFVs = tyCoVarsOfCosSet cenv+  tenvFVs = shallowTyCoVarsOfTyVarEnv tenv+  cenvFVs = shallowTyCoVarsOfCoVarEnv cenv  -- | This checks if the substitution satisfies the invariant from -- Note [The substitution invariant].@@ -628,9 +629,9 @@   = ASSERT2( isValidTCvSubst subst,              text "in_scope" <+> ppr in_scope $$              text "tenv" <+> ppr tenv $$-             text "tenvFVs" <+> ppr (tyCoVarsOfTypesSet tenv) $$+             text "tenvFVs" <+> ppr (shallowTyCoVarsOfTyVarEnv tenv) $$              text "cenv" <+> ppr cenv $$-             text "cenvFVs" <+> ppr (tyCoVarsOfCosSet cenv) $$+             text "cenvFVs" <+> ppr (shallowTyCoVarsOfCoVarEnv cenv) $$              text "tys" <+> ppr tys $$              text "cos" <+> ppr cos )     ASSERT2( tysCosFVsInScope,@@ -645,8 +646,9 @@   substDomain = nonDetKeysUFM tenv ++ nonDetKeysUFM cenv     -- It's OK to use nonDetKeysUFM here, because we only use this list to     -- remove some elements from a set-  needInScope = (tyCoVarsOfTypes tys `unionVarSet` tyCoVarsOfCos cos)-                  `delListFromUniqSet_Directly` substDomain+  needInScope = (shallowTyCoVarsOfTypes tys `unionVarSet`+                 shallowTyCoVarsOfCos cos)+                `delListFromUniqSet_Directly` substDomain   tysCosFVsInScope = needInScope `varSetInScope` in_scope  @@ -817,7 +819,6 @@                                 in cs1 `seqList` AxiomRuleCo c cs1     go (HoleCo h)            = HoleCo $! go_hole h -    go_prov UnsafeCoerceProv     = UnsafeCoerceProv     go_prov (PhantomProv kco)    = PhantomProv (go kco)     go_prov (ProofIrrelProv kco) = ProofIrrelProv (go kco)     go_prov p@(PluginProv _)     = p@@ -958,7 +959,7 @@     new_env | no_change = delVarEnv tenv old_var             | otherwise = extendVarEnv tenv old_var (TyVarTy new_var) -    _no_capture = not (new_var `elemVarSet` tyCoVarsOfTypesSet tenv)+    _no_capture = not (new_var `elemVarSet` shallowTyCoVarsOfTyVarEnv tenv)     -- Assertion check that we are not capturing something in the substitution      old_ki = tyVarKind old_var@@ -1027,4 +1028,3 @@     (uniq, usupply') = takeUniqFromSupply usupply     (subst' , tv )   = cloneTyVarBndr subst t uniq     (subst'', tvs)   = cloneTyVarBndrs subst' ts usupply'-

compiler/types/TyCoTidy.hs view

@@ -28,7 +28,7 @@ import VarEnv import Util (seqList) -import Data.List+import Data.List (mapAccumL)  {- %************************************************************************@@ -227,7 +227,6 @@     go (AxiomRuleCo ax cos)  = let cos1 = tidyCos env cos                                in cos1 `seqList` AxiomRuleCo ax cos1 -    go_prov UnsafeCoerceProv    = UnsafeCoerceProv     go_prov (PhantomProv co)    = PhantomProv (go co)     go_prov (ProofIrrelProv co) = ProofIrrelProv (go co)     go_prov p@(PluginProv _)    = p

compiler/types/TyCon.hs view

@@ -148,7 +148,7 @@ import VarSet import Class import BasicTypes-import DynFlags+import GHC.Driver.Session import ForeignCall import Name import NameEnv@@ -644,8 +644,8 @@   but it's enforced by etaExpandAlgTyCon -} -instance Outputable tv => Outputable (VarBndr tv TyConBndrVis) where-  ppr (Bndr v bi) = ppr_bi bi <+> parens (ppr v)+instance OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) where+  ppr (Bndr v bi) = ppr_bi bi <+> parens (pprBndr LetBind v)     where       ppr_bi (AnonTCB VisArg)     = text "anon-vis"       ppr_bi (AnonTCB InvisArg)   = text "anon-invis"@@ -689,7 +689,7 @@ -- such as those for function and tuple types.  -- If you edit this type, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs+-- See Note [GHC Formalism] in GHC.Core.Lint data TyCon   = -- | The function type constructor, @(->)@     FunTyCon {@@ -1061,7 +1061,7 @@ data AlgTyConFlav   = -- | An ordinary type constructor has no parent.     VanillaAlgTyCon-       TyConRepName+       TyConRepName   -- For Typeable      -- | An unboxed type constructor. The TyConRepName is a Maybe since we     -- currently don't allow unboxed sums to be Typeable since there are too@@ -1300,9 +1300,10 @@ *                                                                      * ********************************************************************* -} -type TyConRepName = Name -- The Name of the top-level declaration-                         --    $tcMaybe :: Data.Typeable.Internal.TyCon-                         --    $tcMaybe = TyCon { tyConName = "Maybe", ... }+type TyConRepName = Name+   -- The Name of the top-level declaration for the Typeable world+   --    $tcMaybe :: Data.Typeable.Internal.TyCon+   --    $tcMaybe = TyCon { tyConName = "Maybe", ... }  tyConRepName_maybe :: TyCon -> Maybe TyConRepName tyConRepName_maybe (FunTyCon   { tcRepName = rep_nm })@@ -1468,7 +1469,7 @@ isGcPtrRep _           = False  -- A PrimRep is compatible with another iff one can be coerced to the other.--- See Note [bad unsafe coercion] in CoreLint for when are two types coercible.+-- See Note [bad unsafe coercion] in GHC.Core.Lint for when are two types coercible. primRepCompatible :: DynFlags -> PrimRep -> PrimRep -> Bool primRepCompatible dflags rep1 rep2 =     (isUnboxed rep1 == isUnboxed rep2) &&

compiler/types/Type.hs view

@@ -54,6 +54,7 @@         piResultTy, piResultTys,         applyTysX, dropForAlls,         mkFamilyTyConApp,+        buildSynTyCon,          mkNumLitTy, isNumLitTy,         mkStrLitTy, isStrLitTy,@@ -82,6 +83,7 @@          -- ** Analyzing types         TyCoMapper(..), mapType, mapCoercion,+        TyCoFolder(..), foldTyCo,          -- (Newtypes)         newTyConInstRhs,@@ -141,14 +143,16 @@         tyCoVarsOfTypeDSet,         coVarsOfType,         coVarsOfTypes,-        closeOverKindsDSet, closeOverKindsFV, closeOverKindsList,-        closeOverKinds,          noFreeVarsOfType,         splitVisVarsOfType, splitVisVarsOfTypes,         expandTypeSynonyms,         typeSize, occCheckExpand, +        -- ** Closing over kinds+        closeOverKindsDSet, closeOverKindsList,+        closeOverKinds,+         -- * Well-scoped lists of variables         scopedSort, tyCoVarsOfTypeWellScoped,         tyCoVarsOfTypesWellScoped,@@ -239,7 +243,9 @@ import TysPrim import {-# SOURCE #-} TysWiredIn ( listTyCon, typeNatKind                                  , typeSymbolKind, liftedTypeKind+                                 , liftedTypeKindTyCon                                  , constraintKind )+import Name( Name ) import PrelNames import CoAxiom import {-# SOURCE #-} Coercion( mkNomReflCo, mkGReflCo, mkReflCo@@ -464,7 +470,6 @@     go_co _ (HoleCo h)       = pprPanic "expandTypeSynonyms hit a hole" (ppr h) -    go_prov _     UnsafeCoerceProv    = UnsafeCoerceProv     go_prov subst (PhantomProv co)    = PhantomProv (go_co subst co)     go_prov subst (ProofIrrelProv co) = ProofIrrelProv (go_co subst co)     go_prov _     p@(PluginProv _)    = p@@ -550,10 +555,9 @@ isRuntimeRepVar = isRuntimeRepTy . tyVarKind  -{--************************************************************************+{- ********************************************************************* *                                                                      *-   Analyzing types+               mapType *                                                                      * ************************************************************************ @@ -689,11 +693,11 @@     go (KindCo co)         = mkKindCo <$> go co     go (SubCo co)          = mkSubCo <$> go co -    go_prov UnsafeCoerceProv    = return UnsafeCoerceProv     go_prov (PhantomProv co)    = PhantomProv <$> go co     go_prov (ProofIrrelProv co) = ProofIrrelProv <$> go co     go_prov p@(PluginProv _)    = return p + {- ************************************************************************ *                                                                      *@@ -1084,7 +1088,7 @@ -- there are more type args than foralls in 'undefined's type.  -- If you edit this function, you may need to update the GHC formalism--- See Note [GHC Formalism] in coreSyn/CoreLint.hs+-- See Note [GHC Formalism] in GHC.Core.Lint  -- This is a heavily used function (e.g. from typeKind), -- so we pay attention to efficiency, especially in the special case@@ -1173,7 +1177,31 @@  The same thing happens in GHC.CoreToIface.toIfaceAppArgsX. +--------------------------------------+Note [mkTyConApp and Type] +Whilst benchmarking it was observed in #17292 that GHC allocated a lot+of `TyConApp` constructors. Upon further inspection a large number of these+TyConApp constructors were all duplicates of `Type` applied to no arguments.++```+(From a sample of 100000 TyConApp closures)+0x45f3523    - 28732 - `Type`+0x420b840702 - 9629  - generic type constructors+0x42055b7e46 - 9596+0x420559b582 - 9511+0x420bb15a1e - 9509+0x420b86c6ba - 9501+0x42055bac1e - 9496+0x45e68fd    - 538 - `TYPE ...`+```++Therefore in `mkTyConApp` we have a special case for `Type` to ensure that+only one `TyConApp 'Type []` closure is allocated during the course of+compilation. In order to avoid a potentially expensive series of checks in+`mkTyConApp` only this egregious case is special cased at the moment.++ ---------------------------------------------------------------------                                 TyConApp                                 ~~~~~~~~@@ -1185,12 +1213,21 @@ mkTyConApp tycon tys   | isFunTyCon tycon   , [_rep1,_rep2,ty1,ty2] <- tys+  -- The FunTyCon (->) is always a visible one   = FunTy { ft_af = VisArg, ft_arg = ty1, ft_res = ty2 }-    -- The FunTyCon (->) is always a visible one-+  -- Note [mkTyConApp and Type]+  | tycon == liftedTypeKindTyCon+  = ASSERT2( null tys, ppr tycon $$ ppr tys )+    liftedTypeKindTyConApp   | otherwise   = TyConApp tycon tys +-- This is a single, global definition of the type `Type`+-- Defined here so it is only allocated once.+-- See Note [mkTyConApp and Type]+liftedTypeKindTyConApp :: Type+liftedTypeKindTyConApp = TyConApp liftedTypeKindTyCon []+ -- splitTyConApp "looks through" synonyms, because they don't -- mean a distinct type, but all other type-constructor applications -- including functions are returned as Just ..@@ -1857,32 +1894,6 @@ binderRelevantType_maybe (Named {})  = Nothing binderRelevantType_maybe (Anon _ ty) = Just ty -------------- Closing over kinds --------------------- | Add the kind variables free in the kinds of the tyvars in the given set.--- Returns a non-deterministic set.-closeOverKinds :: TyVarSet -> TyVarSet-closeOverKinds = fvVarSet . closeOverKindsFV . nonDetEltsUniqSet-  -- It's OK to use nonDetEltsUniqSet here because we immediately forget-  -- about the ordering by returning a set.---- | Given a list of tyvars returns a deterministic FV computation that--- returns the given tyvars with the kind variables free in the kinds of the--- given tyvars.-closeOverKindsFV :: [TyVar] -> FV-closeOverKindsFV tvs =-  mapUnionFV (tyCoFVsOfType . tyVarKind) tvs `unionFV` mkFVs tvs---- | Add the kind variables free in the kinds of the tyvars in the given set.--- Returns a deterministically ordered list.-closeOverKindsList :: [TyVar] -> [TyVar]-closeOverKindsList tvs = fvVarList $ closeOverKindsFV tvs---- | Add the kind variables free in the kinds of the tyvars in the given set.--- Returns a deterministic set.-closeOverKindsDSet :: DTyVarSet -> DTyVarSet-closeOverKindsDSet = fvDVarSet . closeOverKindsFV . dVarSetElems- {- ************************************************************************ *                                                                      *@@ -1939,6 +1950,15 @@   | otherwise   = False +buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind   -- ^ /result/ kind+              -> [Role] -> KnotTied Type -> TyCon+-- This function is here beucase here is where we have+--   isFamFree and isTauTy+buildSynTyCon name binders res_kind roles rhs+  = mkSynonymTyCon name binders res_kind roles rhs is_tau is_fam_free+  where+    is_tau      = isTauTy rhs+    is_fam_free = isFamFreeTy rhs  {- ************************************************************************@@ -2065,7 +2085,7 @@ -- in its return type, since given --   join j @a @b x y z = e1 in e2, -- the types of e1 and e2 must be the same, and a and b are not in scope for e2.--- (See Note [The polymorphism rule of join points] in CoreSyn.) Returns False+-- (See Note [The polymorphism rule of join points] in GHC.Core.) Returns False -- also if the type simply doesn't have enough arguments. -- -- Note that we need to know how many arguments (type *and* value) the putative@@ -2093,7 +2113,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In principle, if a function would be a join point except that it fails the polymorphism rule (see Note [The polymorphism rule of join points] in-CoreSyn), it can still be made a join point with some effort. This is because+GHC.Core), it can still be made a join point with some effort. This is because all tail calls must return the same type (they return to the same context!), and thus if the return type depends on an argument, that argument must always be the same.@@ -2623,7 +2643,7 @@ -- free of the variable, then the same type is returned. occCheckExpand vs_to_avoid ty   | null vs_to_avoid  -- Efficient shortcut-  = Just ty           -- Can happen, eg. CoreUtils.mkSingleAltCase+  = Just ty           -- Can happen, eg. GHC.Core.Utils.mkSingleAltCase    | otherwise   = go (mkVarSet vs_to_avoid, emptyVarEnv) ty@@ -2737,7 +2757,6 @@                                              ; return (mkAxiomRuleCo ax cs') }      -------------------    go_prov _   UnsafeCoerceProv    = return UnsafeCoerceProv     go_prov cxt (PhantomProv co)    = PhantomProv <$> go_co cxt co     go_prov cxt (ProofIrrelProv co) = ProofIrrelProv <$> go_co cxt co     go_prov _   p@(PluginProv _)    = return p@@ -2791,7 +2810,6 @@      go_mco MRefl    = emptyUniqSet      go_mco (MCo co) = go_co co -     go_prov UnsafeCoerceProv    = emptyUniqSet      go_prov (PhantomProv co)    = go_co co      go_prov (ProofIrrelProv co) = go_co co      go_prov (PluginProv _)      = emptyUniqSet

compiler/utils/Binary.hs view

@@ -1380,10 +1380,24 @@             return (mkRealSrcSpan (mkRealSrcLoc f sl sc)                                   (mkRealSrcLoc f el ec)) +instance Binary BufPos where+  put_ bh (BufPos i) = put_ bh i+  get bh = BufPos <$> get bh++instance Binary BufSpan where+  put_ bh (BufSpan start end) = do+    put_ bh start+    put_ bh end+  get bh = do+    start <- get bh+    end <- get bh+    return (BufSpan start end)+ instance Binary SrcSpan where-  put_ bh (RealSrcSpan ss) = do+  put_ bh (RealSrcSpan ss sb) = do           putByte bh 0           put_ bh ss+          put_ bh sb    put_ bh (UnhelpfulSpan s) = do           putByte bh 1@@ -1393,7 +1407,8 @@           h <- getByte bh           case h of             0 -> do ss <- get bh-                    return (RealSrcSpan ss)+                    sb <- get bh+                    return (RealSrcSpan ss sb)             _ -> do s <- get bh                     return (UnhelpfulSpan s)

compiler/utils/Digraph.hs view

@@ -422,7 +422,7 @@  -- Data.Tree has flatten for Tree, but nothing for Forest preorderF           :: Forest a -> [a]-preorderF ts         = concat (map flatten ts)+preorderF ts         = concatMap flatten ts  {- ------------------------------------------------------------

compiler/utils/FV.hs view

@@ -12,7 +12,7 @@         FV, InterestingVarFun,          -- * Running the computations-        fvVarListVarSet, fvVarList, fvVarSet, fvDVarSet,+        fvVarList, fvVarSet, fvDVarSet,          -- ** Manipulating those computations         unitFV,@@ -46,22 +46,21 @@ -- Merging costs O(n+m) for UniqFM and for UniqDFM there's an additional log -- factor. It's cheaper to incrementally add to a list and use a set to check -- for duplicates.-type FV = InterestingVarFun-             -- Used for filtering sets as we build them-          -> VarSet-             -- Locally bound variables-          -> ([Var], VarSet)-             -- List to preserve ordering and set to check for membership,-             -- so that the list doesn't have duplicates-             -- For explanation of why using `VarSet` is not deterministic see-             -- Note [Deterministic UniqFM] in UniqDFM.-          -> ([Var], VarSet)+type FV = InterestingVarFun -- Used for filtering sets as we build them+        -> VarSet           -- Locally bound variables+        -> VarAcc           -- Accumulator+        -> VarAcc +type VarAcc = ([Var], VarSet)  -- List to preserve ordering and set to check for membership,+                               -- so that the list doesn't have duplicates+                               -- For explanation of why using `VarSet` is not deterministic see+                               -- Note [Deterministic UniqFM] in UniqDFM.+ -- Note [FV naming conventions] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- To get the performance and determinism that FV provides, FV computations -- need to built up from smaller FV computations and then evaluated with--- one of `fvVarList`, `fvDVarSet`, `fvVarListVarSet`. That means the functions+-- one of `fvVarList`, `fvDVarSet` That means the functions -- returning FV need to be exported. -- -- The conventions are:@@ -84,26 +83,26 @@ -- | Run a free variable computation, returning a list of distinct free -- variables in deterministic order and a non-deterministic set containing -- those variables.-fvVarListVarSet :: FV ->  ([Var], VarSet)-fvVarListVarSet fv = fv (const True) emptyVarSet ([], emptyVarSet)+fvVarAcc :: FV ->  ([Var], VarSet)+fvVarAcc fv = fv (const True) emptyVarSet ([], emptyVarSet)  -- | Run a free variable computation, returning a list of distinct free -- variables in deterministic order. fvVarList :: FV -> [Var]-fvVarList = fst . fvVarListVarSet+fvVarList = fst . fvVarAcc  -- | Run a free variable computation, returning a deterministic set of free -- variables. Note that this is just a wrapper around the version that -- returns a deterministic list. If you need a list you should use -- `fvVarList`. fvDVarSet :: FV -> DVarSet-fvDVarSet = mkDVarSet . fst . fvVarListVarSet+fvDVarSet = mkDVarSet . fvVarList  -- | Run a free variable computation, returning a non-deterministic set of -- free variables. Don't use if the set will be later converted to a list -- and the order of that list will impact the generated code. fvVarSet :: FV -> VarSet-fvVarSet = snd . fvVarListVarSet+fvVarSet = snd . fvVarAcc  -- Note [FV eta expansion] -- ~~~~~~~~~~~~~~~~~~~~~~~

compiler/utils/IOEnv.hs view

@@ -33,7 +33,7 @@  import GhcPrelude -import DynFlags+import GHC.Driver.Session import Exception import Module import Panic

compiler/utils/ListSetOps.hs view

@@ -28,7 +28,7 @@ import Outputable import Util -import Data.List+import qualified Data.List as L import qualified Data.List.NonEmpty as NE import Data.List.NonEmpty (NonEmpty(..)) import qualified Data.Set as S@@ -40,7 +40,7 @@ deleteBys :: (a -> a -> Bool) -> [a] -> [a] -> [a] -- (deleteBys eq xs ys) returns xs-ys, using the given equality function -- Just like 'Data.List.delete' but with an equality function-deleteBys eq xs ys = foldl' (flip (deleteBy eq)) xs ys+deleteBys eq xs ys = foldl' (flip (L.deleteBy eq)) xs ys  {- ************************************************************************@@ -153,7 +153,7 @@  equivClasses _   []      = [] equivClasses _   [stuff] = [stuff :| []]-equivClasses cmp items   = NE.groupBy eq (sortBy cmp items)+equivClasses cmp items   = NE.groupBy eq (L.sortBy cmp items)   where     eq a b = case cmp a b of { EQ -> True; _ -> False } @@ -166,7 +166,7 @@ removeDups _   []  = ([], []) removeDups _   [x] = ([x],[]) removeDups cmp xs-  = case (mapAccumR collect_dups [] (equivClasses cmp xs)) of { (dups, xs') ->+  = case L.mapAccumR collect_dups [] (equivClasses cmp xs) of { (dups, xs') ->     (xs', dups) }   where     collect_dups :: [NonEmpty a] -> NonEmpty a -> ([NonEmpty a], a)@@ -175,6 +175,6 @@  findDupsEq :: (a->a->Bool) -> [a] -> [NonEmpty a] findDupsEq _  [] = []-findDupsEq eq (x:xs) | null eq_xs  = findDupsEq eq xs-                     | otherwise   = (x :| eq_xs) : findDupsEq eq neq_xs-    where (eq_xs, neq_xs) = partition (eq x) xs+findDupsEq eq (x:xs) | L.null eq_xs  = findDupsEq eq xs+                     | otherwise     = (x :| eq_xs) : findDupsEq eq neq_xs+    where (eq_xs, neq_xs) = L.partition (eq x) xs

compiler/utils/Outputable.hs view

@@ -1,3 +1,5 @@+{-# LANGUAGE LambdaCase #-}+ {- (c) The University of Glasgow 2006-2012 (c) The GRASP Project, Glasgow University, 1992-1998@@ -34,6 +36,7 @@         sep, cat,         fsep, fcat,         hang, hangNotEmpty, punctuate, ppWhen, ppUnless,+        ppWhenOption, ppUnlessOption,         speakNth, speakN, speakNOf, plural, isOrAre, doOrDoes, itsOrTheir,         unicodeSyntax, @@ -68,14 +71,16 @@         neverQualify, neverQualifyNames, neverQualifyModules,         alwaysQualifyPackages, neverQualifyPackages,         QualifyName(..), queryQual,-        sdocWithDynFlags, sdocWithPlatform,-        updSDocDynFlags,-        getPprStyle, withPprStyle, withPprStyleDoc, setStyleColoured,+        sdocWithDynFlags, sdocWithPlatform, sdocOption,+        updSDocContext,+        SDocContext (..), sdocWithContext,+        getPprStyle, withPprStyle, setStyleColoured,         pprDeeper, pprDeeperList, pprSetDepth,         codeStyle, userStyle, debugStyle, dumpStyle, asmStyle,         qualName, qualModule, qualPackage,         mkErrStyle, defaultErrStyle, defaultDumpStyle, mkDumpStyle, defaultUserStyle,         mkUserStyle, cmdlineParserStyle, Depth(..),+        withUserStyle, withErrStyle,          ifPprDebug, whenPprDebug, getPprDebug, @@ -89,11 +94,11 @@  import GhcPrelude -import {-# SOURCE #-}   DynFlags( DynFlags, hasPprDebug, hasNoDebugOutput,-                                  targetPlatform, pprUserLength, pprCols,-                                  useUnicode, useUnicodeSyntax,-                                  shouldUseColor, unsafeGlobalDynFlags,-                                  shouldUseHexWordLiterals )+import {-# SOURCE #-}   GHC.Driver.Session+                           ( DynFlags, hasPprDebug, hasNoDebugOutput+                           , targetPlatform, pprUserLength, pprCols+                           , unsafeGlobalDynFlags, initSDocContext+                           ) import {-# SOURCE #-}   Module( UnitId, Module, ModuleName, moduleName ) import {-# SOURCE #-}   OccName( OccName ) @@ -194,7 +199,7 @@ -- the component id to disambiguate it. type QueryQualifyPackage = UnitId -> Bool --- See Note [Printing original names] in HscTypes+-- See Note [Printing original names] in GHC.Driver.Types data QualifyName   -- Given P:M.T   = NameUnqual           -- It's in scope unqualified as "T"                          -- OR nothing called "T" is in scope@@ -281,6 +286,16 @@    | hasPprDebug dflags = PprDebug    | otherwise          = PprUser unqual depth Uncoloured +withUserStyle :: PrintUnqualified -> Depth -> SDoc -> SDoc+withUserStyle unqual depth doc = sdocOption sdocPprDebug $ \case+   True  -> withPprStyle PprDebug doc+   False -> withPprStyle (PprUser unqual depth Uncoloured) doc++withErrStyle :: PrintUnqualified -> SDoc -> SDoc+withErrStyle unqual doc =+   sdocWithDynFlags $ \dflags ->+   withPprStyle (mkErrStyle dflags unqual) doc+ setStyleColoured :: Bool -> PprStyle -> PprStyle setStyleColoured col style =   case style of@@ -320,10 +335,43 @@ newtype SDoc = SDoc { runSDoc :: SDocContext -> Doc }  data SDocContext = SDC-  { sdocStyle      :: !PprStyle-  , sdocLastColour :: !Col.PprColour-    -- ^ The most recently used colour.  This allows nesting colours.-  , sdocDynFlags   :: !DynFlags+  { sdocStyle                       :: !PprStyle+  , sdocColScheme                   :: !Col.Scheme+  , sdocLastColour                  :: !Col.PprColour+      -- ^ The most recently used colour.+      -- This allows nesting colours.+  , sdocShouldUseColor              :: !Bool+  , sdocLineLength                  :: !Int+  , sdocCanUseUnicode               :: !Bool+      -- ^ True if Unicode encoding is supported+      -- and not disable by GHC_NO_UNICODE environment variable+  , sdocHexWordLiterals             :: !Bool+  , sdocDebugLevel                  :: !Int+  , sdocPprDebug                    :: !Bool+  , sdocPrintUnicodeSyntax          :: !Bool+  , sdocPrintCaseAsLet              :: !Bool+  , sdocPrintTypecheckerElaboration :: !Bool+  , sdocPrintAxiomIncomps           :: !Bool+  , sdocPrintExplicitKinds          :: !Bool+  , sdocPrintExplicitCoercions      :: !Bool+  , sdocPrintExplicitRuntimeReps    :: !Bool+  , sdocPrintExplicitForalls        :: !Bool+  , sdocPrintPotentialInstances     :: !Bool+  , sdocPrintEqualityRelations      :: !Bool+  , sdocSuppressTicks               :: !Bool+  , sdocSuppressTypeSignatures      :: !Bool+  , sdocSuppressTypeApplications    :: !Bool+  , sdocSuppressIdInfo              :: !Bool+  , sdocSuppressCoercions           :: !Bool+  , sdocSuppressUnfoldings          :: !Bool+  , sdocSuppressVarKinds            :: !Bool+  , sdocSuppressUniques             :: !Bool+  , sdocSuppressModulePrefixes      :: !Bool+  , sdocSuppressStgExts             :: !Bool+  , sdocErrorSpans                  :: !Bool+  , sdocStarIsType                  :: !Bool+  , sdocImpredicativeTypes          :: !Bool+  , sdocDynFlags                    :: DynFlags -- TODO: remove   }  instance IsString SDoc where@@ -333,22 +381,10 @@ instance Outputable SDoc where   ppr = id -initSDocContext :: DynFlags -> PprStyle -> SDocContext-initSDocContext dflags sty = SDC-  { sdocStyle = sty-  , sdocLastColour = Col.colReset-  , sdocDynFlags = dflags-  }  withPprStyle :: PprStyle -> SDoc -> SDoc withPprStyle sty d = SDoc $ \ctxt -> runSDoc d ctxt{sdocStyle=sty} --- | This is not a recommended way to render 'SDoc', since it breaks the--- abstraction layer of 'SDoc'.  Prefer to use 'printSDoc', 'printSDocLn',--- 'bufLeftRenderSDoc', or 'renderWithStyle' instead.-withPprStyleDoc :: DynFlags -> PprStyle -> SDoc -> Doc-withPprStyleDoc dflags sty d = runSDoc d (initSDocContext dflags sty)- pprDeeper :: SDoc -> SDoc pprDeeper d = SDoc $ \ctx -> case ctx of   SDC{sdocStyle=PprUser _ (PartWay 0) _} -> Pretty.text "..."@@ -389,10 +425,16 @@ sdocWithPlatform :: (Platform -> SDoc) -> SDoc sdocWithPlatform f = sdocWithDynFlags (f . targetPlatform) -updSDocDynFlags :: (DynFlags -> DynFlags) -> SDoc -> SDoc-updSDocDynFlags upd doc-  = SDoc $ \ctx -> runSDoc doc (ctx { sdocDynFlags = upd (sdocDynFlags ctx) })+sdocWithContext :: (SDocContext -> SDoc) -> SDoc+sdocWithContext f = SDoc $ \ctx -> runSDoc (f ctx) ctx +sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc+sdocOption f g = sdocWithContext (g . f)++updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc+updSDocContext upd doc+  = SDoc $ \ctx -> runSDoc doc (upd ctx)+ qualName :: PprStyle -> QueryQualifyName qualName (PprUser q _ _) mod occ = queryQualifyName q mod occ qualName (PprDump q)     mod occ = queryQualifyName q mod occ@@ -495,7 +537,7 @@ -- However, Doc *is* an instance of Show -- showSDoc just blasts it out as a string showSDoc :: DynFlags -> SDoc -> String-showSDoc dflags sdoc = renderWithStyle dflags sdoc (defaultUserStyle dflags)+showSDoc dflags sdoc = renderWithStyle (initSDocContext dflags (defaultUserStyle dflags)) sdoc  -- showSDocUnsafe is unsafe, because `unsafeGlobalDynFlags` might not be -- initialised yet.@@ -512,19 +554,19 @@ showSDocForUser :: DynFlags -> PrintUnqualified -> SDoc -> String -- Allows caller to specify the PrintUnqualified to use showSDocForUser dflags unqual doc- = renderWithStyle dflags doc (mkUserStyle dflags unqual AllTheWay)+ = renderWithStyle (initSDocContext dflags (mkUserStyle dflags unqual AllTheWay)) doc  showSDocDump :: DynFlags -> SDoc -> String-showSDocDump dflags d = renderWithStyle dflags d (defaultDumpStyle dflags)+showSDocDump dflags d = renderWithStyle (initSDocContext dflags (defaultDumpStyle dflags)) d  showSDocDebug :: DynFlags -> SDoc -> String-showSDocDebug dflags d = renderWithStyle dflags d PprDebug+showSDocDebug dflags d = renderWithStyle (initSDocContext dflags PprDebug) d -renderWithStyle :: DynFlags -> SDoc -> PprStyle -> String-renderWithStyle dflags sdoc sty-  = let s = Pretty.style{ Pretty.mode = PageMode,-                          Pretty.lineLength = pprCols dflags }-    in Pretty.renderStyle s $ runSDoc sdoc (initSDocContext dflags sty)+renderWithStyle :: SDocContext -> SDoc -> String+renderWithStyle ctx sdoc+  = let s = Pretty.style{ Pretty.mode       = PageMode,+                          Pretty.lineLength = sdocLineLength ctx }+    in Pretty.renderStyle s $ runSDoc sdoc ctx  -- This shows an SDoc, but on one line only. It's cheaper than a full -- showSDoc, designed for when we're getting results like "Foo.bar"@@ -547,9 +589,8 @@ -- Used for OneLineMode and LeftMode when number of cols isn't used irrelevantNCols = 1 -isEmpty :: DynFlags -> SDoc -> Bool-isEmpty dflags sdoc = Pretty.isEmpty $ runSDoc sdoc dummySDocContext-   where dummySDocContext = initSDocContext dflags PprDebug+isEmpty :: SDocContext -> SDoc -> Bool+isEmpty ctx sdoc = Pretty.isEmpty $ runSDoc sdoc (ctx {sdocStyle = PprDebug})  docToSDoc :: Doc -> SDoc docToSDoc d = SDoc (\_ -> d)@@ -581,11 +622,10 @@ float n     = docToSDoc $ Pretty.float n double n    = docToSDoc $ Pretty.double n rational n  = docToSDoc $ Pretty.rational n-word n      = sdocWithDynFlags $ \dflags ->-    -- See Note [Print Hexadecimal Literals] in Pretty.hs-    if shouldUseHexWordLiterals dflags-        then docToSDoc $ Pretty.hex n-        else docToSDoc $ Pretty.integer n+              -- See Note [Print Hexadecimal Literals] in Pretty.hs+word n      = sdocOption sdocHexWordLiterals $ \case+               True  -> docToSDoc $ Pretty.hex n+               False -> docToSDoc $ Pretty.integer n  -- | @doublePrec p n@ shows a floating point number @n@ with @p@ -- digits of precision after the decimal point.@@ -608,17 +648,15 @@ -- 'quotes' encloses something in single quotes... -- but it omits them if the thing begins or ends in a single quote -- so that we don't get `foo''.  Instead we just have foo'.-quotes d =-      sdocWithDynFlags $ \dflags ->-      if useUnicode dflags-      then char '‘' <> d <> char '’'-      else SDoc $ \sty ->-           let pp_d = runSDoc d sty-               str  = show pp_d-           in case (str, lastMaybe str) of-             (_, Just '\'') -> pp_d-             ('\'' : _, _)       -> pp_d-             _other              -> Pretty.quotes pp_d+quotes d = sdocOption sdocCanUseUnicode $ \case+   True  -> char '‘' <> d <> char '’'+   False -> SDoc $ \sty ->+      let pp_d = runSDoc d sty+          str  = show pp_d+      in case (str, lastMaybe str) of+        (_, Just '\'') -> pp_d+        ('\'' : _, _)       -> pp_d+        _other              -> Pretty.quotes pp_d  semi, comma, colon, equals, space, dcolon, underscore, dot, vbar :: SDoc arrow, larrow, darrow, arrowt, larrowt, arrowtt, larrowtt :: SDoc@@ -655,16 +693,17 @@ bullet = unicode (char '•') (char '*')  unicodeSyntax :: SDoc -> SDoc -> SDoc-unicodeSyntax unicode plain = sdocWithDynFlags $ \dflags ->-    if useUnicode dflags && useUnicodeSyntax dflags+unicodeSyntax unicode plain =+   sdocOption sdocCanUseUnicode $ \can_use_unicode ->+   sdocOption sdocPrintUnicodeSyntax $ \print_unicode_syntax ->+    if can_use_unicode && print_unicode_syntax     then unicode     else plain  unicode :: SDoc -> SDoc -> SDoc-unicode unicode plain = sdocWithDynFlags $ \dflags ->-    if useUnicode dflags-    then unicode-    else plain+unicode unicode plain = sdocOption sdocCanUseUnicode $ \case+   True  -> unicode+   False -> plain  nest :: Int -> SDoc -> SDoc -- ^ Indent 'SDoc' some specified amount@@ -737,22 +776,29 @@ ppUnless True  _   = empty ppUnless False doc = doc +ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc+ppWhenOption f doc = sdocOption f $ \case+   True  -> doc+   False -> empty++ppUnlessOption :: (SDocContext -> Bool) -> SDoc -> SDoc+ppUnlessOption f doc = sdocOption f $ \case+   True  -> empty+   False -> doc+ -- | Apply the given colour\/style for the argument. -- -- Only takes effect if colours are enabled. coloured :: Col.PprColour -> SDoc -> SDoc-coloured col sdoc =-  sdocWithDynFlags $ \dflags ->-    if shouldUseColor dflags-    then SDoc $ \ctx@SDC{ sdocLastColour = lastCol } ->-         case ctx of-           SDC{ sdocStyle = PprUser _ _ Coloured } ->-             let ctx' = ctx{ sdocLastColour = lastCol `mappend` col } in-             Pretty.zeroWidthText (Col.renderColour col)-               Pretty.<> runSDoc sdoc ctx'-               Pretty.<> Pretty.zeroWidthText (Col.renderColourAfresh lastCol)-           _ -> runSDoc sdoc ctx-    else sdoc+coloured col sdoc = sdocOption sdocShouldUseColor $ \case+   True -> SDoc $ \case+      ctx@SDC{ sdocLastColour = lastCol, sdocStyle = PprUser _ _ Coloured } ->+         let ctx' = ctx{ sdocLastColour = lastCol `mappend` col } in+         Pretty.zeroWidthText (Col.renderColour col)+           Pretty.<> runSDoc sdoc ctx'+           Pretty.<> Pretty.zeroWidthText (Col.renderColourAfresh lastCol)+      ctx -> runSDoc sdoc ctx+   False -> sdoc  keyword :: SDoc -> SDoc keyword = coloured Col.colBold@@ -916,7 +962,7 @@ -- | 'BindingSite' is used to tell the thing that prints binder what -- language construct is binding the identifier.  This can be used -- to decide how much info to print.--- Also see Note [Binding-site specific printing] in PprCore+-- Also see Note [Binding-site specific printing] in GHC.Core.Ppr data BindingSite     = LambdaBind  -- ^ The x in   (\x. e)     | CaseBind    -- ^ The x in   case scrut of x { (y,z) -> ... }

compiler/utils/Outputable.hs-boot view

@@ -4,6 +4,8 @@ import GHC.Stack( HasCallStack )  data SDoc+data PprStyle+data SDocContext  showSDocUnsafe :: SDoc -> String

compiler/utils/TrieMap.hs view

@@ -39,6 +39,7 @@ import qualified Data.IntMap as IntMap import Outputable import Control.Monad( (>=>) )+import Data.Kind( Type )  {- This module implements TrieMaps, which are finite mappings@@ -46,7 +47,7 @@  This file implements tries over general data structures. Implementation for tries over Core Expressions/Types are-available in coreSyn/TrieMap.+available in GHC.Core.Map.  The regular pattern for handling TrieMaps on data structures was first described (to my knowledge) in Connelly and Morris's 1995 paper "A@@ -65,7 +66,7 @@                                 --               or an existing elt (Just)  class TrieMap m where-   type Key m :: *+   type Key m :: Type    emptyTM  :: m a    lookupTM :: forall b. Key m -> m b -> Maybe b    alterTM  :: forall b. Key m -> XT b -> m b -> m b@@ -332,7 +333,7 @@ nothing in the map, don't bother building out the (possibly infinite) recursive TrieMap structure! -Compressed triemaps are heavily used by CoreMap. So we have to mark some things+Compressed triemaps are heavily used by GHC.Core.Map. So we have to mark some things as INLINEABLE to permit specialization. -}

compiler/utils/Util.hs view

@@ -80,7 +80,7 @@         transitiveClosure,          -- * Strictness-        seqList,+        seqList, strictMap,          -- * Module names         looksLikeModuleName,@@ -1008,6 +1008,14 @@ seqList [] b = b seqList (x:xs) b = x `seq` seqList xs b +strictMap :: (a -> b) -> [a] -> [b]+strictMap _ [] = []+strictMap f (x : xs) =+  let+    !x' = f x+    !xs' = strictMap f xs+  in+    x' : xs'  {- ************************************************************************@@ -1283,8 +1291,7 @@ -- also results in a skip.  withAtomicRename :: (MonadIO m) => FilePath -> (FilePath -> m a) -> m a-withAtomicRename targetFile f-  | enableAtomicRename = do+withAtomicRename targetFile f = do   -- The temp file must be on the same file system (mount) as the target file   -- to result in an atomic move on most platforms.   -- The standard way to ensure that is to place it into the same directory.@@ -1294,17 +1301,6 @@   res <- f temp   liftIO $ renameFile temp targetFile   return res--  | otherwise = f targetFile-  where-    -- As described in #16450, enabling this causes spurious build failures due-    -- to apparently missing files.-    enableAtomicRename :: Bool-#if defined(mingw32_BUILD_OS)-    enableAtomicRename = False-#else-    enableAtomicRename = True-#endif  -- -------------------------------------------------------------- -- split a string at the last character where 'pred' is True,

ghc-lib-parser.cabal view

@@ -1,7 +1,7 @@ cabal-version: >=1.22 build-type: Simple name: ghc-lib-parser-version: 0.20200205+version: 0.20200301 license: BSD3 license-file: LICENSE category: Development@@ -129,22 +129,17 @@         libraries/template-haskell         libraries/ghc-boot-th         compiler/basicTypes-        compiler/specialise-        compiler/nativeGen         compiler/profiling         compiler/simplCore         compiler/typecheck         libraries/ghc-boot         libraries/ghc-heap-        compiler/backpack-        compiler/coreSyn         compiler/prelude         compiler/parser         compiler/iface         compiler/types         compiler/utils         libraries/ghci-        compiler/ghci         compiler/main         compiler/.         compiler@@ -159,39 +154,24 @@         BasicTypes         BinFingerprint         Binary-        BkpSyn         BooleanFormula         BufWrite-        ByteCodeTypes         Class         CliOption-        CmdLineParser         CoAxiom         Coercion         ConLike         Config         Constants         Constraint-        CoreArity-        CoreFVs-        CoreMap         CoreMonad-        CoreOpt-        CoreSeq-        CoreStats-        CoreSubst-        CoreSyn-        CoreTidy-        CoreUnfold-        CoreUtils         CostCentre         CostCentreState+        Cpr         Ctype         DataCon         Demand         Digraph-        DriverPhases-        DynFlags         Encoding         EnumSet         ErrUtils@@ -209,6 +189,7 @@         FiniteMap         ForeignCall         GHC.BaseDir+        GHC.ByteCode.Types         GHC.Cmm         GHC.Cmm.BlockId         GHC.Cmm.CLabel@@ -221,7 +202,31 @@         GHC.Cmm.Node         GHC.Cmm.Switch         GHC.Cmm.Type+        GHC.Core+        GHC.Core.Arity+        GHC.Core.FVs+        GHC.Core.Make+        GHC.Core.Map+        GHC.Core.Op.Tidy+        GHC.Core.Ppr+        GHC.Core.Rules+        GHC.Core.Seq+        GHC.Core.SimpleOpt+        GHC.Core.Stats+        GHC.Core.Subst+        GHC.Core.Unfold+        GHC.Core.Utils         GHC.CoreToIface+        GHC.Driver.Backpack.Syntax+        GHC.Driver.CmdLine+        GHC.Driver.Hooks+        GHC.Driver.Monad+        GHC.Driver.Packages+        GHC.Driver.Phases+        GHC.Driver.Pipeline.Monad+        GHC.Driver.Plugins+        GHC.Driver.Session+        GHC.Driver.Types         GHC.Exts.Heap         GHC.Exts.Heap.ClosureTypes         GHC.Exts.Heap.Closures@@ -243,7 +248,6 @@         GHC.Hs.Instances         GHC.Hs.Lit         GHC.Hs.Pat-        GHC.Hs.PlaceHolder         GHC.Hs.Types         GHC.Hs.Utils         GHC.HsToCore.PmCheck.Types@@ -258,12 +262,17 @@         GHC.Platform.ARM64         GHC.Platform.NoRegs         GHC.Platform.PPC+        GHC.Platform.Reg+        GHC.Platform.Reg.Class         GHC.Platform.Regs         GHC.Platform.S390X         GHC.Platform.SPARC         GHC.Platform.X86         GHC.Platform.X86_64-        GHC.Runtime.Layout+        GHC.Runtime.Eval.Types+        GHC.Runtime.Heap.Layout+        GHC.Runtime.Interpreter.Types+        GHC.Runtime.Linker.Types         GHC.Serialized         GHC.Stg.Syntax         GHC.Types.RepType@@ -274,18 +283,14 @@         GHCi.Message         GHCi.RemoteTypes         GHCi.TH.Binary-        GhcMonad         GhcNameVersion         GhcPrelude         HaddockUtils         HeaderInfo-        Hooks-        HscTypes         IOEnv         Id         IdInfo         InstEnv-        InteractiveEvalTypes         Json         KnownUniques         Language.Haskell.TH@@ -298,11 +303,9 @@         Language.Haskell.TH.Syntax         Lexeme         Lexer-        LinkerTypes         ListSetOps         Literal         Maybes-        MkCore         MkId         Module         MonadUtils@@ -315,17 +318,13 @@         OptCoercion         OrdList         Outputable-        Packages         Pair         Panic         Parser         PatSyn-        PipelineMonad         PlainPanic         PlatformConstants-        Plugins         PprColour-        PprCore         Predicate         PrelNames         PrelRules@@ -333,9 +332,6 @@         PrimOp         RdrHsSyn         RdrName-        Reg-        RegClass-        Rules         Settings         SizedSeq         SrcLoc

ghc-lib/stage0/compiler/build/Lexer.hs view

@@ -2,7 +2,6 @@ {-# LANGUAGE CPP,MagicHash #-} {-# LINE 43 "compiler/parser/Lexer.x" #-} -{-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE MultiWayIf #-}@@ -18,7 +17,7 @@    allocateComments,    MonadP(..),    getRealSrcLoc, getPState, withThisPackage,-   failLocMsgP, srcParseFail,+   failMsgP, failLocMsgP, srcParseFail,    getErrorMessages, getMessages,    popContext, pushModuleContext, setLastToken, setSrcLoc,    activeContext, nextIsEOF,@@ -35,7 +34,6 @@  -- base import Control.Monad-import Control.Monad.Fail as MonadFail import Data.Bits import Data.Char import Data.List@@ -65,7 +63,7 @@  -- compiler/main import ErrUtils-import DynFlags+import GHC.Driver.Session as DynFlags  -- compiler/basicTypes import SrcLoc@@ -574,7 +572,7 @@   , (0,alex_action_112)   ] -{-# LINE 663 "compiler/parser/Lexer.x" #-}+{-# LINE 661 "compiler/parser/Lexer.x" #-}   -- -----------------------------------------------------------------------------@@ -739,11 +737,11 @@   | ITdollar                            --  prefix $   | ITdollardollar                      --  prefix $$   | ITtyQuote                           --  ''-  | ITquasiQuote (FastString,FastString,RealSrcSpan)+  | ITquasiQuote (FastString,FastString,PsSpan)     -- ITquasiQuote(quoter, quote, loc)     -- represents a quasi-quote of the form     -- [quoter| quote |]-  | ITqQuasiQuote (FastString,FastString,FastString,RealSrcSpan)+  | ITqQuasiQuote (FastString,FastString,FastString,PsSpan)     -- ITqQuasiQuote(Qual, quoter, quote, loc)     -- represents a qualified quasi-quote of the form     -- [Qual.quoter| quote |]@@ -912,7 +910,7 @@ -- ----------------------------------------------------------------------------- -- Lexer actions -type Action = RealSrcSpan -> StringBuffer -> Int -> P (RealLocated Token)+type Action = PsSpan -> StringBuffer -> Int -> P (PsLocated Token)  special :: Token -> Action special tok span _buf _len = return (L span tok)@@ -962,13 +960,13 @@  = do relaxed <- getBit RelaxedLayoutBit       ctx <- getContext       (AI l _) <- getInput-      let offset = srcLocCol l+      let offset = srcLocCol (psRealLoc l)           isOK = relaxed ||                  case ctx of                  Layout prev_off _ : _ -> prev_off < offset                  _                     -> True       if isOK then pop_and open_brace span buf len-              else addFatalError (RealSrcSpan span) (text "Missing block")+              else addFatalError (mkSrcSpanPs span) (text "Missing block")  pop_and :: Action -> Action pop_and act span buf len = do _ <- popLexState@@ -1103,7 +1101,7 @@   nested comments require traversing by hand, they can't be parsed   using regular expressions. -}-nested_comment :: P (RealLocated Token) -> Action+nested_comment :: P (PsLocated Token) -> Action nested_comment cont span buf len = do   input <- getInput   go (reverse $ lexemeToString buf len) (1::Int) input@@ -1115,18 +1113,18 @@         then docCommentEnd input commentAcc ITblockComment buf span         else cont     go commentAcc n input = case alexGetChar' input of-      Nothing -> errBrace input span+      Nothing -> errBrace input (psRealSpan span)       Just ('-',input) -> case alexGetChar' input of-        Nothing  -> errBrace input span+        Nothing  -> errBrace input (psRealSpan span)         Just ('\125',input) -> go ('\125':'-':commentAcc) (n-1) input -- '}'         Just (_,_)          -> go ('-':commentAcc) n input       Just ('\123',input) -> case alexGetChar' input of  -- '{' char-        Nothing  -> errBrace input span+        Nothing  -> errBrace input (psRealSpan span)         Just ('-',input) -> go ('-':'\123':commentAcc) (n+1) input         Just (_,_)       -> go ('\123':commentAcc) n input       -- See Note [Nested comment line pragmas]       Just ('\n',input) -> case alexGetChar' input of-        Nothing  -> errBrace input span+        Nothing  -> errBrace input (psRealSpan span)         Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input                            go (parsedAcc ++ '\n':commentAcc) n input         Just (_,_)   -> go ('\n':commentAcc) n input@@ -1136,14 +1134,14 @@ nested_doc_comment span buf _len = withLexedDocType (go "")   where     go commentAcc input docType _ = case alexGetChar' input of-      Nothing -> errBrace input span+      Nothing -> errBrace input (psRealSpan span)       Just ('-',input) -> case alexGetChar' input of-        Nothing -> errBrace input span+        Nothing -> errBrace input (psRealSpan span)         Just ('\125',input) ->           docCommentEnd input commentAcc docType buf span         Just (_,_) -> go ('-':commentAcc) input docType False       Just ('\123', input) -> case alexGetChar' input of-        Nothing  -> errBrace input span+        Nothing  -> errBrace input (psRealSpan span)         Just ('-',input) -> do           setInput input           let cont = do input <- getInput; go commentAcc input docType False@@ -1151,7 +1149,7 @@         Just (_,_) -> go ('\123':commentAcc) input docType False       -- See Note [Nested comment line pragmas]       Just ('\n',input) -> case alexGetChar' input of-        Nothing  -> errBrace input span+        Nothing  -> errBrace input (psRealSpan span)         Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input                            go (parsedAcc ++ '\n':commentAcc) input docType False         Just (_,_)   -> go ('\n':commentAcc) input docType False@@ -1169,7 +1167,7 @@   setExts (.&. complement (xbit InNestedCommentBit))   postInput@(AI _ postBuf) <- getInput   setInput origInput-  case unRealSrcSpan lt of+  case unLoc lt of     ITcomment_line_prag -> do       let bytes = byteDiff buf postBuf           diff  = lexemeToString buf bytes@@ -1203,8 +1201,8 @@ See #314 for more background on the bug this fixes. -} -withLexedDocType :: (AlexInput -> (String -> Token) -> Bool -> P (RealLocated Token))-                 -> P (RealLocated Token)+withLexedDocType :: (AlexInput -> (String -> Token) -> Bool -> P (PsLocated Token))+                 -> P (PsLocated Token) withLexedDocType lexDocComment = do   input@(AI _ buf) <- getInput   case prevChar buf ' ' of@@ -1264,19 +1262,19 @@ -- called afterwards, so it can just update the state.  docCommentEnd :: AlexInput -> String -> (String -> Token) -> StringBuffer ->-                 RealSrcSpan -> P (RealLocated Token)+                 PsSpan -> P (PsLocated Token) docCommentEnd input commentAcc docType buf span = do   setInput input   let (AI loc nextBuf) = input       comment = reverse commentAcc-      span' = mkRealSrcSpan (realSrcSpanStart span) loc+      span' = mkPsSpan (psSpanStart span) loc       last_len = byteDiff buf nextBuf    span `seq` setLastToken span' last_len   return (L span' (docType comment))  errBrace :: AlexInput -> RealSrcSpan -> P a-errBrace (AI end _) span = failLocMsgP (realSrcSpanStart span) end "unterminated `{-'"+errBrace (AI end _) span = failLocMsgP (realSrcSpanStart span) (psRealLoc end) "unterminated `{-'"  open_brace, close_brace :: Action open_brace span _str _len = do@@ -1331,7 +1329,7 @@           lambdaCase <- getBit LambdaCaseBit           unless lambdaCase $ do             pState <- getPState-            addError (RealSrcSpan (last_loc pState)) $ text+            addError (mkSrcSpanPs (last_loc pState)) $ text                      "Illegal lambda-case (use LambdaCase)"           return ITlcase         _ -> return ITcase@@ -1365,9 +1363,9 @@ varsym_prefix = sym $ \exts s ->   if | TypeApplicationsBit `xtest` exts, s == fsLit "@"      -> return ITtypeApp-     | ThBit `xtest` exts, s == fsLit "$"+     | ThQuotesBit `xtest` exts, s == fsLit "$"      -> return ITdollar-     | ThBit `xtest` exts, s == fsLit "$$"+     | ThQuotesBit `xtest` exts, s == fsLit "$$"      -> return ITdollardollar      | s == fsLit "!" -> return ITbang      | s == fsLit "~" -> return ITtilde@@ -1430,7 +1428,7 @@   let src = lexemeToString buf len   when ((not numericUnderscores) && ('_' `elem` src)) $ do     pState <- getPState-    addError (RealSrcSpan (last_loc pState)) $ text+    addError (mkSrcSpanPs (last_loc pState)) $ text              "Use NumericUnderscores to allow underscores in integer literals"   return $ L span $ itint (SourceText src)        $! transint $ parseUnsignedInteger@@ -1472,7 +1470,7 @@   let src = lexemeToString buf (len-drop)   when ((not numericUnderscores) && ('_' `elem` src)) $ do     pState <- getPState-    addError (RealSrcSpan (last_loc pState)) $ text+    addError (mkSrcSpanPs (last_loc pState)) $ text              "Use NumericUnderscores to allow underscores in floating literals"   return (L span $! (f $! src)) @@ -1553,7 +1551,7 @@ new_layout_context strict gen_semic tok span _buf len = do     _ <- popLexState     (AI l _) <- getInput-    let offset = srcLocCol l - len+    let offset = srcLocCol (psRealLoc l) - len     ctx <- getContext     nondecreasing <- getBit NondecreasingIndentationBit     let strict' = strict || not nondecreasing@@ -1578,7 +1576,7 @@ -- LINE pragmas  setLineAndFile :: Int -> Action-setLineAndFile code span buf len = do+setLineAndFile code (PsSpan span _) buf len = do   let src = lexemeToString buf (len - 1)  -- drop trailing quotation mark       linenumLen = length $ head $ words src       linenum = parseUnsignedInteger buf linenumLen 10 octDecDigit@@ -1596,7 +1594,7 @@               -- System.FilePath.normalise before printing out               -- filenames and it does not remove duplicate               -- backslashes after the drive letter (should it?).-  setAlrLastLoc $ alrInitialLoc file+  resetAlrLastLoc file   setSrcLoc (mkRealSrcLoc file (fromIntegral linenum - 1) (srcSpanEndCol span))       -- subtract one: the line number refers to the *following* line   addSrcFile file@@ -1605,7 +1603,7 @@   lexToken  setColumn :: Action-setColumn span buf len = do+setColumn (PsSpan span _) buf len = do   let column =         case reads (lexemeToString buf len) of           [(column, _)] -> column@@ -1627,10 +1625,10 @@ lex_string_prag :: (String -> Token) -> Action lex_string_prag mkTok span _buf _len     = do input <- getInput-         start <- getRealSrcLoc+         start <- getParsedLoc          tok <- go [] input-         end <- getRealSrcLoc-         return (L (mkRealSrcSpan start end) tok)+         end <- getParsedLoc+         return (L (mkPsSpan start end) tok)     where go acc input               = if isString input "#-}"                    then do setInput input@@ -1643,7 +1641,7 @@               = case alexGetChar i of                   Just (c,i') | c == x    -> isString i' xs                   _other -> False-          err (AI end _) = failLocMsgP (realSrcSpanStart span) end "unterminated options pragma"+          err (AI end _) = failLocMsgP (realSrcSpanStart (psRealSpan span)) (psRealLoc end) "unterminated options pragma"   -- -----------------------------------------------------------------------------@@ -1661,7 +1659,7 @@             ITstring _ s -> ITstring (SourceText src) s             _ -> panic "lex_string_tok"     src = lexemeToString buf (cur bufEnd - cur buf)-  return (L (mkRealSrcSpan (realSrcSpanStart span) end) tok')+  return (L (mkPsSpan (psSpanStart span) end) tok')  lex_string :: String -> P Token lex_string s = do@@ -1681,7 +1679,7 @@                 setInput i                 when (any (> '\xFF') s') $ do                   pState <- getPState-                  addError (RealSrcSpan (last_loc pState)) $ text+                  addError (mkSrcSpanPs (last_loc pState)) $ text                      "primitive string literal must contain only characters <= \'\\xFF\'"                 return (ITprimstring (SourceText s') (unsafeMkByteString s'))               _other ->@@ -1723,13 +1721,13 @@ -- see if there's a trailing quote lex_char_tok span buf _len = do        -- We've seen '    i1 <- getInput       -- Look ahead to first character-   let loc = realSrcSpanStart span+   let loc = psSpanStart span    case alexGetChar' i1 of         Nothing -> lit_error  i1          Just ('\'', i2@(AI end2 _)) -> do       -- We've seen ''                    setInput i2-                   return (L (mkRealSrcSpan loc end2)  ITtyQuote)+                   return (L (mkPsSpan loc end2)  ITtyQuote)          Just ('\\', i2@(AI _end2 _)) -> do      -- We've seen 'backslash                   setInput i2@@ -1753,9 +1751,9 @@                                         -- (including the possibility of EOF)                                         -- Just parse the quote only                         let (AI end _) = i1-                        return (L (mkRealSrcSpan loc end) ITsimpleQuote)+                        return (L (mkPsSpan loc end) ITsimpleQuote) -finish_char_tok :: StringBuffer -> RealSrcLoc -> Char -> P (RealLocated Token)+finish_char_tok :: StringBuffer -> PsLoc -> Char -> P (PsLocated Token) finish_char_tok buf loc ch  -- We've already seen the closing quote                         -- Just need to check for trailing #   = do  magicHash <- getBit MagicHashBit@@ -1765,13 +1763,13 @@             case alexGetChar' i of               Just ('#',i@(AI end _)) -> do                 setInput i-                return (L (mkRealSrcSpan loc end)+                return (L (mkPsSpan loc end)                           (ITprimchar (SourceText src) ch))               _other ->-                return (L (mkRealSrcSpan loc end)+                return (L (mkPsSpan loc end)                           (ITchar (SourceText src) ch))             else do-              return (L (mkRealSrcSpan loc end) (ITchar (SourceText src) ch))+              return (L (mkPsSpan loc end) (ITchar (SourceText src) ch))  isAny :: Char -> Bool isAny c | c > '\x7f' = isPrint c@@ -1901,27 +1899,27 @@ lex_qquasiquote_tok :: Action lex_qquasiquote_tok span buf len = do   let (qual, quoter) = splitQualName (stepOn buf) (len - 2) False-  quoteStart <- getRealSrcLoc-  quote <- lex_quasiquote quoteStart ""-  end <- getRealSrcLoc-  return (L (mkRealSrcSpan (realSrcSpanStart span) end)+  quoteStart <- getParsedLoc+  quote <- lex_quasiquote (psRealLoc quoteStart) ""+  end <- getParsedLoc+  return (L (mkPsSpan (psSpanStart span) end)            (ITqQuasiQuote (qual,                            quoter,                            mkFastString (reverse quote),-                           mkRealSrcSpan quoteStart end)))+                           mkPsSpan quoteStart end)))  lex_quasiquote_tok :: Action lex_quasiquote_tok span buf len = do   let quoter = tail (lexemeToString buf (len - 1))                 -- 'tail' drops the initial '[',                 -- while the -1 drops the trailing '|'-  quoteStart <- getRealSrcLoc-  quote <- lex_quasiquote quoteStart ""-  end <- getRealSrcLoc-  return (L (mkRealSrcSpan (realSrcSpanStart span) end)+  quoteStart <- getParsedLoc+  quote <- lex_quasiquote (psRealLoc quoteStart) ""+  end <- getParsedLoc+  return (L (mkPsSpan (psSpanStart span) end)            (ITquasiQuote (mkFastString quoter,                           mkFastString (reverse quote),-                          mkRealSrcSpan quoteStart end)))+                          mkPsSpan quoteStart end)))  lex_quasiquote :: RealSrcLoc -> String -> P String lex_quasiquote start s = do@@ -1943,19 +1941,19 @@ quasiquote_error :: RealSrcLoc -> P a quasiquote_error start = do   (AI end buf) <- getInput-  reportLexError start end buf "unterminated quasiquotation"+  reportLexError start (psRealLoc end) buf "unterminated quasiquotation"  -- ----------------------------------------------------------------------------- -- Warnings  warnTab :: Action warnTab srcspan _buf _len = do-    addTabWarning srcspan+    addTabWarning (psRealSpan srcspan)     lexToken  warnThen :: WarningFlag -> SDoc -> Action -> Action warnThen option warning action srcspan buf len = do-    addWarning option (RealSrcSpan srcspan) warning+    addWarning option (RealSrcSpan (psRealSpan srcspan) Nothing) warning     action srcspan buf len  -- -----------------------------------------------------------------------------@@ -2010,22 +2008,22 @@         tab_first  :: Maybe RealSrcSpan, -- pos of first tab warning in the file         tab_count  :: !Int,              -- number of tab warnings in the file         last_tk    :: Maybe Token,-        last_loc   :: RealSrcSpan, -- pos of previous token+        last_loc   :: PsSpan,      -- pos of previous token         last_len   :: !Int,        -- len of previous token-        loc        :: RealSrcLoc,  -- current loc (end of prev token + 1)+        loc        :: PsLoc,       -- current loc (end of prev token + 1)         context    :: [LayoutContext],         lex_state  :: [Int],         srcfiles   :: [FastString],         -- Used in the alternative layout rule:         -- These tokens are the next ones to be sent out. They are         -- just blindly emitted, without the rule looking at them again:-        alr_pending_implicit_tokens :: [RealLocated Token],+        alr_pending_implicit_tokens :: [PsLocated Token],         -- This is the next token to be considered or, if it is Nothing,         -- we need to get the next token from the input stream:-        alr_next_token :: Maybe (RealLocated Token),+        alr_next_token :: Maybe (PsLocated Token),         -- This is what we consider to be the location of the last token         -- emitted:-        alr_last_loc :: RealSrcSpan,+        alr_last_loc :: PsSpan,         -- The stack of layout contexts:         alr_context :: [ALRContext],         -- Are we expecting a '{'? If it's Just, then the ALRLayout tells@@ -2039,9 +2037,10 @@         -- locations of 'noise' tokens in the source, so that users of         -- the GHC API can do source to source conversions.         -- See note [Api annotations] in ApiAnnotation.hs-        annotations :: [(ApiAnnKey,[SrcSpan])],-        comment_q :: [Located AnnotationComment],-        annotations_comments :: [(SrcSpan,[Located AnnotationComment])]+        annotations :: [(ApiAnnKey,[RealSrcSpan])],+        eof_pos :: Maybe RealSrcSpan,+        comment_q :: [RealLocated AnnotationComment],+        annotations_comments :: [(RealSrcSpan,[RealLocated AnnotationComment])]      }         -- last_loc and last_len are used when generating error messages,         -- and in pushCurrentContext only.  Sigh, if only Happy passed the@@ -2069,13 +2068,7 @@  instance Monad P where   (>>=) = thenP-#if !MIN_VERSION_base(4,13,0)-  fail = MonadFail.fail-#endif -instance MonadFail.MonadFail P where-  fail = failMsgP- returnP :: a -> P a returnP a = a `seq` (P $ \s -> POk s a) @@ -2088,11 +2081,11 @@ failMsgP :: String -> P a failMsgP msg = do   pState <- getPState-  addFatalError (RealSrcSpan (last_loc pState)) (text msg)+  addFatalError (mkSrcSpanPs (last_loc pState)) (text msg)  failLocMsgP :: RealSrcLoc -> RealSrcLoc -> String -> P a failLocMsgP loc1 loc2 str =-  addFatalError (RealSrcSpan (mkRealSrcSpan loc1 loc2)) (text str)+  addFatalError (RealSrcSpan (mkRealSrcSpan loc1 loc2) Nothing) (text str)  getPState :: P PState getPState = P $ \s -> POk s s@@ -2111,15 +2104,23 @@   } ()  setSrcLoc :: RealSrcLoc -> P ()-setSrcLoc new_loc = P $ \s -> POk s{loc=new_loc} ()+setSrcLoc new_loc =+  P $ \s@(PState{ loc = PsLoc _ buf_loc }) ->+  POk s{ loc = PsLoc new_loc buf_loc } ()  getRealSrcLoc :: P RealSrcLoc-getRealSrcLoc = P $ \s@(PState{ loc=loc }) -> POk s loc+getRealSrcLoc = P $ \s@(PState{ loc=loc }) -> POk s (psRealLoc loc) +getParsedLoc :: P PsLoc+getParsedLoc  = P $ \s@(PState{ loc=loc }) -> POk s loc+ addSrcFile :: FastString -> P () addSrcFile f = P $ \s -> POk s{ srcfiles = f : srcfiles s } () -setLastToken :: RealSrcSpan -> Int -> P ()+setEofPos :: RealSrcSpan -> P ()+setEofPos span = P $ \s -> POk s{ eof_pos = Just span } ()++setLastToken :: PsSpan -> Int -> P () setLastToken loc len = P $ \s -> POk s {   last_loc=loc,   last_len=len@@ -2131,7 +2132,7 @@ getLastTk :: P (Maybe Token) getLastTk = P $ \s@(PState { last_tk = last_tk }) -> POk s last_tk -data AlexInput = AI RealSrcLoc StringBuffer+data AlexInput = AI PsLoc StringBuffer  {- Note [Unicode in Alex]@@ -2224,7 +2225,7 @@                 --trace (show (ord c)) $                 Just (byte, (AI loc' s'))   where (c,s') = nextChar s-        loc'   = advanceSrcLoc loc c+        loc'   = advancePsLoc loc c         byte   = adjustChar c  -- This version does not squash unicode characters, it is used when@@ -2236,7 +2237,7 @@                 --trace (show (ord c)) $                 Just (c, (AI loc' s'))   where (c,s') = nextChar s-        loc'   = advanceSrcLoc loc c+        loc'   = advancePsLoc loc c  getInput :: P AlexInput getInput = P $ \s@PState{ loc=l, buffer=b } -> POk s (AI l b)@@ -2258,7 +2259,7 @@ getLexState :: P Int getLexState = P $ \s@PState{ lex_state=ls:_ } -> POk s ls -popNextToken :: P (Maybe (RealLocated Token))+popNextToken :: P (Maybe (PsLocated Token)) popNextToken     = P $ \s@PState{ alr_next_token = m } ->               POk (s {alr_next_token = Nothing}) m@@ -2272,10 +2273,15 @@     ([],Nothing) -> return impt     _other       -> return True -setAlrLastLoc :: RealSrcSpan -> P ()+resetAlrLastLoc :: FastString -> P ()+resetAlrLastLoc file =+  P $ \s@(PState {alr_last_loc = PsSpan _ buf_span}) ->+  POk s{ alr_last_loc = PsSpan (alrInitialLoc file) buf_span } ()++setAlrLastLoc :: PsSpan -> P () setAlrLastLoc l = P $ \s -> POk (s {alr_last_loc = l}) () -getAlrLastLoc :: P RealSrcSpan+getAlrLastLoc :: P PsSpan getAlrLastLoc = P $ \s@(PState {alr_last_loc = l}) -> POk s l  getALRContext :: P [ALRContext]@@ -2292,7 +2298,7 @@ setJustClosedExplicitLetBlock b  = P $ \s -> POk (s {alr_justClosedExplicitLetBlock = b}) () -setNextToken :: RealLocated Token -> P ()+setNextToken :: PsLocated Token -> P () setNextToken t = P $ \s -> POk (s {alr_next_token = Just t}) ()  implicitTokenPending :: P Bool@@ -2302,14 +2308,14 @@               [] -> POk s False               _  -> POk s True -popPendingImplicitToken :: P (Maybe (RealLocated Token))+popPendingImplicitToken :: P (Maybe (PsLocated Token)) popPendingImplicitToken     = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->               case ts of               [] -> POk s Nothing               (t : ts') -> POk (s {alr_pending_implicit_tokens = ts'}) (Just t) -setPendingImplicitTokens :: [RealLocated Token] -> P ()+setPendingImplicitTokens :: [PsLocated Token] -> P () setPendingImplicitTokens ts = P $ \s -> POk (s {alr_pending_implicit_tokens = ts}) ()  getAlrExpectingOCurly :: P (Maybe ALRLayout)@@ -2501,22 +2507,24 @@       tab_first     = Nothing,       tab_count     = 0,       last_tk       = Nothing,-      last_loc      = mkRealSrcSpan loc loc,+      last_loc      = mkPsSpan init_loc init_loc,       last_len      = 0,-      loc           = loc,+      loc           = init_loc,       context       = [],       lex_state     = [bol, 0],       srcfiles      = [],       alr_pending_implicit_tokens = [],       alr_next_token = Nothing,-      alr_last_loc = alrInitialLoc (fsLit "<no file>"),+      alr_last_loc = PsSpan (alrInitialLoc (fsLit "<no file>")) (BufSpan (BufPos 0) (BufPos 0)),       alr_context = [],       alr_expecting_ocurly = Nothing,       alr_justClosedExplicitLetBlock = False,       annotations = [],+      eof_pos = Nothing,       comment_q = [],       annotations_comments = []     }+  where init_loc = PsLoc loc (BufPos 0)  -- | An mtl-style class for monads that support parsing-related operations. -- For example, sometimes we make a second pass over the parsing results to validate,@@ -2593,9 +2601,10 @@     addError span msg >> P PFailed   getBit ext = P $ \s -> let b =  ext `xtest` pExtsBitmap (options s)                          in b `seq` POk s b-  addAnnotation l a v = do+  addAnnotation (RealSrcSpan l _) a (RealSrcSpan v _) = do     addAnnotationOnly l a v     allocateCommentsP l+  addAnnotation _ _ _ = return ()  addAnnsAt :: MonadP m => SrcSpan -> [AddAnn] -> m () addAnnsAt l = mapM_ (\(AddAnn a v) -> addAnnotation l a v)@@ -2620,7 +2629,7 @@                 <> text "."                 $+$ text "Please use spaces instead."   in fmap (\s -> makeIntoWarning (Reason Opt_WarnTabs) $-                 mkWarnMsg d (RealSrcSpan s) alwaysQualify message) tf+                 mkWarnMsg d (RealSrcSpan s Nothing) alwaysQualify message) tf  -- | Get a bag of the errors that have been accumulated so far. --   Does not take -Werror into account.@@ -2650,12 +2659,12 @@         (_:tl) ->           POk s{ context = tl } ()         []     ->-          unP (addFatalError (RealSrcSpan last_loc) (srcParseErr o buf len)) s+          unP (addFatalError (mkSrcSpanPs last_loc) (srcParseErr o buf len)) s  -- Push a new layout context at the indentation of the last token read. pushCurrentContext :: GenSemic -> P () pushCurrentContext gen_semic = P $ \ s@PState{ last_loc=loc, context=ctx } ->-    POk s{context = Layout (srcSpanStartCol loc) gen_semic : ctx} ()+    POk s{context = Layout (srcSpanStartCol (psRealSpan loc)) gen_semic : ctx} ()  -- This is only used at the outer level of a module when the 'module' keyword is -- missing.@@ -2664,7 +2673,7 @@  getOffside :: P (Ordering, Bool) getOffside = P $ \s@PState{last_loc=loc, context=stk} ->-                let offs = srcSpanStartCol loc in+                let offs = srcSpanStartCol (psRealSpan loc) in                 let ord = case stk of                             Layout n gen_semic : _ ->                               --trace ("layout: " ++ show n ++ ", offs: " ++ show offs) $@@ -2701,7 +2710,7 @@         last100 = decodePrevNChars 100 buf         doInLast100 = "do" `isInfixOf` last100         mdoInLast100 = "mdo" `isInfixOf` last100-        th_enabled = ThBit `xtest` pExtsBitmap options+        th_enabled = ThQuotesBit `xtest` pExtsBitmap options         ps_enabled = PatternSynonymsBit `xtest` pExtsBitmap options  -- Report a parse failure, giving the span of the previous token as@@ -2710,7 +2719,7 @@ srcParseFail :: P a srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len,                             last_loc = last_loc } ->-    unP (addFatalError (RealSrcSpan last_loc) (srcParseErr o buf len)) s+    unP (addFatalError (mkSrcSpanPs last_loc) (srcParseErr o buf len)) s  -- A lexical error is reported at a particular position in the source file, -- not over a token range.@@ -2718,7 +2727,7 @@ lexError str = do   loc <- getRealSrcLoc   (AI end buf) <- getInput-  reportLexError loc end buf str+  reportLexError loc (psRealLoc end) buf str  -- ----------------------------------------------------------------------------- -- This is the top-level function: called from the parser each time a@@ -2732,24 +2741,20 @@   (L span tok) <- lexTokenFun   --trace ("token: " ++ show tok) $ do -  case tok of-    ITeof -> addAnnotationOnly noSrcSpan AnnEofPos (RealSrcSpan span)-    _ -> return ()-   if (queueComments && isDocComment tok)-    then queueComment (L (RealSrcSpan span) tok)+    then queueComment (L (psRealSpan span) tok)     else return ()    if (queueComments && isComment tok)-    then queueComment (L (RealSrcSpan span) tok) >> lexer queueComments cont-    else cont (L (RealSrcSpan span) tok)+    then queueComment (L (psRealSpan span) tok) >> lexer queueComments cont+    else cont (L (mkSrcSpanPs span) tok)  -- Use this instead of 'lexer' in Parser.y to dump the tokens for debugging. lexerDbg queueComments cont = lexer queueComments contDbg   where     contDbg tok = trace ("token: " ++ show (unLoc tok)) (cont tok) -lexTokenAlr :: P (RealLocated Token)+lexTokenAlr :: P (PsLocated Token) lexTokenAlr = do mPending <- popPendingImplicitToken                  t <- case mPending of                       Nothing ->@@ -2760,8 +2765,8 @@                              alternativeLayoutRuleToken t                       Just t ->                           return t-                 setAlrLastLoc (getRealSrcSpan t)-                 case unRealSrcSpan t of+                 setAlrLastLoc (getLoc t)+                 case unLoc t of                      ITwhere -> setAlrExpectingOCurly (Just ALRLayoutWhere)                      ITlet   -> setAlrExpectingOCurly (Just ALRLayoutLet)                      ITof    -> setAlrExpectingOCurly (Just ALRLayoutOf)@@ -2772,7 +2777,7 @@                      _       -> return ()                  return t -alternativeLayoutRuleToken :: RealLocated Token -> P (RealLocated Token)+alternativeLayoutRuleToken :: PsLocated Token -> P (PsLocated Token) alternativeLayoutRuleToken t     = do context <- getALRContext          lastLoc <- getAlrLastLoc@@ -2780,10 +2785,10 @@          transitional <- getBit ALRTransitionalBit          justClosedExplicitLetBlock <- getJustClosedExplicitLetBlock          setJustClosedExplicitLetBlock False-         let thisLoc = getRealSrcSpan t-             thisCol = srcSpanStartCol thisLoc-             newLine = srcSpanStartLine thisLoc > srcSpanEndLine lastLoc-         case (unRealSrcSpan t, context, mExpectingOCurly) of+         let thisLoc = getLoc t+             thisCol = srcSpanStartCol (psRealSpan thisLoc)+             newLine = srcSpanStartLine (psRealSpan thisLoc) > srcSpanEndLine (psRealSpan lastLoc)+         case (unLoc t, context, mExpectingOCurly) of              -- This case handles a GHC extension to the original H98              -- layout rule...              (ITocurly, _, Just alrLayout) ->@@ -2842,7 +2847,7 @@              (ITwhere, ALRLayout _ col : ls, _)               | newLine && thisCol == col && transitional ->                  do addWarning Opt_WarnAlternativeLayoutRuleTransitional-                               (RealSrcSpan thisLoc)+                               (mkSrcSpanPs thisLoc)                                (transitionalAlternativeLayoutWarning                                     "`where' clause at the same depth as implicit layout block")                     setALRContext ls@@ -2854,7 +2859,7 @@              (ITvbar, ALRLayout _ col : ls, _)               | newLine && thisCol == col && transitional ->                  do addWarning Opt_WarnAlternativeLayoutRuleTransitional-                               (RealSrcSpan thisLoc)+                               (mkSrcSpanPs thisLoc)                                (transitionalAlternativeLayoutWarning                                     "`|' at the same depth as implicit layout block")                     setALRContext ls@@ -2865,8 +2870,8 @@              (_, ALRLayout _ col : ls, _)               | newLine && thisCol == col ->                  do setNextToken t-                    let loc = realSrcSpanStart thisLoc-                        zeroWidthLoc = mkRealSrcSpan loc loc+                    let loc = psSpanStart thisLoc+                        zeroWidthLoc = mkPsSpan loc loc                     return (L zeroWidthLoc ITsemi)               | newLine && thisCol < col ->                  do setALRContext ls@@ -2970,28 +2975,29 @@ topNoLayoutContainsCommas (ALRLayout _ _ : ls) = topNoLayoutContainsCommas ls topNoLayoutContainsCommas (ALRNoLayout b _ : _) = b -lexToken :: P (RealLocated Token)+lexToken :: P (PsLocated Token) lexToken = do   inp@(AI loc1 buf) <- getInput   sc <- getLexState   exts <- getExts   case alexScanUser exts inp sc of     AlexEOF -> do-        let span = mkRealSrcSpan loc1 loc1+        let span = mkPsSpan loc1 loc1+        setEofPos (psRealSpan span)         setLastToken span 0         return (L span ITeof)     AlexError (AI loc2 buf) ->-        reportLexError loc1 loc2 buf "lexical error"+        reportLexError (psRealLoc loc1) (psRealLoc loc2) buf "lexical error"     AlexSkip inp2 _ -> do         setInput inp2         lexToken     AlexToken inp2@(AI end buf2) _ t -> do         setInput inp2-        let span = mkRealSrcSpan loc1 end+        let span = mkPsSpan loc1 end         let bytes = byteDiff buf buf2         span `seq` setLastToken span bytes         lt <- t span buf bytes-        let lt' = unRealSrcSpan lt+        let lt' = unLoc lt         unless (isComment lt') (setLastTk lt')         return lt @@ -3126,7 +3132,7 @@ --   function, and then it can be discharged using the 'ams' function. data AddAnn = AddAnn AnnKeywordId SrcSpan -addAnnotationOnly :: SrcSpan -> AnnKeywordId -> SrcSpan -> P ()+addAnnotationOnly :: RealSrcSpan -> AnnKeywordId -> RealSrcSpan -> P () addAnnotationOnly l a v = P $ \s -> POk s {   annotations = ((l,a), [v]) : annotations s   } ()@@ -3136,24 +3142,24 @@ -- and end of the span mkParensApiAnn :: SrcSpan -> [AddAnn] mkParensApiAnn (UnhelpfulSpan _)  = []-mkParensApiAnn s@(RealSrcSpan ss) = [AddAnn AnnOpenP lo,AddAnn AnnCloseP lc]+mkParensApiAnn (RealSrcSpan ss _) = [AddAnn AnnOpenP lo,AddAnn AnnCloseP lc]   where     f = srcSpanFile ss     sl = srcSpanStartLine ss     sc = srcSpanStartCol ss     el = srcSpanEndLine ss     ec = srcSpanEndCol ss-    lo = mkSrcSpan (srcSpanStart s)         (mkSrcLoc f sl (sc+1))-    lc = mkSrcSpan (mkSrcLoc f el (ec - 1)) (srcSpanEnd s)+    lo = RealSrcSpan (mkRealSrcSpan (realSrcSpanStart ss)        (mkRealSrcLoc f sl (sc+1))) Nothing+    lc = RealSrcSpan (mkRealSrcSpan (mkRealSrcLoc f el (ec - 1)) (realSrcSpanEnd ss))        Nothing -queueComment :: Located Token -> P()+queueComment :: RealLocated Token -> P() queueComment c = P $ \s -> POk s {   comment_q = commentToAnnotation c : comment_q s   } ()  -- | Go through the @comment_q@ in @PState@ and remove all comments -- that belong within the given span-allocateCommentsP :: SrcSpan -> P ()+allocateCommentsP :: RealSrcSpan -> P () allocateCommentsP ss = P $ \s ->   let (comment_q', newAnns) = allocateComments ss (comment_q s) in     POk s {@@ -3162,13 +3168,13 @@      } ()  allocateComments-  :: SrcSpan-  -> [Located AnnotationComment]-  -> ([Located AnnotationComment], [(SrcSpan,[Located AnnotationComment])])+  :: RealSrcSpan+  -> [RealLocated AnnotationComment]+  -> ([RealLocated AnnotationComment], [(RealSrcSpan,[RealLocated AnnotationComment])]) allocateComments ss comment_q =   let-    (before,rest)  = break (\(L l _) -> isSubspanOf l ss) comment_q-    (middle,after) = break (\(L l _) -> not (isSubspanOf l ss)) rest+    (before,rest)  = break (\(L l _) -> isRealSubspanOf l ss) comment_q+    (middle,after) = break (\(L l _) -> not (isRealSubspanOf l ss)) rest     comment_q' = before ++ after     newAnns = if null middle then []                              else [(ss,middle)]@@ -3176,7 +3182,7 @@     (comment_q', newAnns)  -commentToAnnotation :: Located Token -> Located AnnotationComment+commentToAnnotation :: RealLocated Token -> RealLocated AnnotationComment commentToAnnotation (L l (ITdocCommentNext s))  = L l (AnnDocCommentNext s) commentToAnnotation (L l (ITdocCommentPrev s))  = L l (AnnDocCommentPrev s) commentToAnnotation (L l (ITdocCommentNamed s)) = L l (AnnDocCommentNamed s)

ghc-lib/stage0/compiler/build/Parser.hs view

@@ -37,15 +37,16 @@ import Data.Maybe       ( maybeToList ) import Control.Monad    ( mplus ) import Control.Applicative ((<$))+import qualified Prelude  -- compiler/hsSyn import GHC.Hs  -- compiler/main-import DriverPhases     ( HscSource(..) )-import HscTypes         ( IsBootInterface, WarningTxt(..) )-import DynFlags-import BkpSyn+import GHC.Driver.Phases     ( HscSource(..) )+import GHC.Driver.Types         ( IsBootInterface, WarningTxt(..) )+import GHC.Driver.Session+import GHC.Driver.Backpack.Syntax import UnitInfo  -- compiler/utils@@ -2338,26 +2339,26 @@   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\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\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\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\xe0\xd0\x40\x44\xff\xff\xf1\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\xc0\xbf\xf9\xaa\xff\xff\xf2\x7f\x35\x83\x20\x70\x00\x44\x85\x33\xff\xff\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x80\xc0\x01\x10\x15\xce\xfc\x3f\xbc\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\x0e\xcd\x45\xf4\xff\x97\xff\x23\x10\x04\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\xfe\xe0\x00\x00\x02\x07\x40\x54\x38\xf3\xff\xf0\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\x10\x10\x00\xd1\xef\x4f\xf8\x01\x00\x80\x00\x12\x82\x28\xe8\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x51\xf0\x7b\x06\x00\x20\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\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\x40\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\x01\x01\x10\xfd\xfe\x84\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x01\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\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\x04\x04\x40\xf0\xe3\x13\x7e\x00\x00\x00\x00\x00\x00\x02\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x00\x00\x00\x07\x22\x0a\x1c\xc1\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x00\x00\x0e\x44\x14\x38\x82\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x00\x00\x00\x70\x20\xa2\xc0\x11\x0c\x00\x40\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\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\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x98\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc8\xc3\x11\x87\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\x23\x1a\x7f\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x00\x00\x00\x00\x00\x30\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\x10\x10\x00\xd1\xef\x4f\xf8\x01\x00\x80\x00\x12\x82\x28\xe8\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0f\x00\x00\x00\x00\x00\x44\x85\x33\xff\x0f\xaf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\x92\x10\x80\x20\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\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\x02\x02\x20\xfa\xfd\x09\x3f\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc1\x01\x00\x04\x0e\x80\xa8\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe1\x80\x88\x0a\x67\xfe\x1f\x5e\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\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\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\x1c\x1a\x88\xe8\xff\x2f\xfc\x00\x00\x00\x02\x06\x40\x54\x38\xf3\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x70\x68\x20\xa2\xff\xbf\xf0\x03\x00\x00\x08\x18\x00\x51\xe1\xcc\xff\xc3\xeb\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\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\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\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\x87\x06\x22\xfa\xff\x0b\x3f\x00\x00\x80\x81\x01\x10\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x17\x7f\x00\x00\x00\x01\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x00\x02\x06\x40\x54\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x5f\xf8\x01\x00\x00\x04\x0c\x80\xa8\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x09\x3c\x04\x53\xf1\xff\xff\xc3\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x52\x78\x08\xe2\xf2\xff\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\xa4\xf0\x10\x44\xe7\xff\xff\x0f\xaf\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\x80\x01\x01\x10\xfd\xfe\x84\x1f\x00\x00\x00\x00\x00\x88\x0a\x67\xfe\x1f\x5e\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\x02\x02\x20\xfa\xfd\x09\x3f\x00\x00\x00\x00\x00\x10\x05\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x51\xe1\xcc\xff\xc3\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x00\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x00\x80\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\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x80\xc0\x01\x10\x15\xce\xfc\x3f\xbc\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\x06\x04\x40\xf4\xfb\x13\x7e\x00\x00\x00\x00\x00\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x90\x10\x00\x40\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\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\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\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\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\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\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\x04\x04\x40\xf4\xfb\x13\x7e\x00\x00\x00\x00\x00\x00\x02\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\x08\x08\x80\xe8\xf7\x27\xfc\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\x80\x28\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\x70\x68\x20\xa2\xff\xbf\xf8\x83\x03\x00\x29\x3c\x04\x71\xf9\xff\xff\xc3\xeb\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x90\x10\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x02\x00\x00\xc0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x06\x04\x42\xf0\xfb\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x10\x10\x00\xd1\xef\x4f\xf8\x01\x00\x00\x00\x00\x80\x28\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\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\x07\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\x80\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x44\x01\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\x01\x01\x52\xfd\xfe\x84\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\xc0\xa1\x81\x88\xfe\xff\xc2\x0f\x00\x00\x20\x60\x00\x44\x85\x33\xff\x0f\xaf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xf0\x03\x00\x00\x08\x18\x00\x51\xe1\xcc\xff\xc3\xeb\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x90\x10\x80\x20\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\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\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\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\x20\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x08\x80\xe8\xf7\x27\xfc\x00\x00\x00\x00\x00\x04\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x02\x00\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x60\x00\x02\x78\x38\xa2\xe0\x77\x0c\x00\x40\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\xc0\x80\x00\x08\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x18\x00\x80\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\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x0c\x08\x80\xe0\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x8e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x51\xf0\x3b\x06\x00\x20\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x00\x02\x07\x40\x54\x38\xf3\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x60\x00\x02\x78\x38\xa2\xe0\xf7\x0c\x08\x40\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\xc0\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\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\x80\x01\x01\x10\xfc\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\x01\xf2\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\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x00\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\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\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x48\xe0\x21\x88\xca\xff\xff\x1f\x5e\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x90\xc2\x43\x10\x15\xff\xff\x3f\xbc\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\x00\x00\x00\x02\x06\x40\x54\x38\xf3\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\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\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\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\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\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\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x04\x90\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\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\x00\x00\x02\x02\x20\xfa\xfd\x09\x3f\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\x00\x00\x00\x02\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\x10\x10\x00\xd1\xef\x4f\xf8\x01\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\x00\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x51\xf0\x7b\x06\x00\x20\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\x40\x40\x00\x44\xbf\x3f\xe1\x07\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\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\x87\xe6\x22\xfa\xff\xcb\xff\x11\x08\x82\xc0\x01\x10\x15\xce\xfc\xff\xbf\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\x0e\xcd\x45\xf4\xff\x97\xff\x23\x10\x04\x81\x03\x20\x2a\x9c\xf9\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x28\xf8\x3d\x03\x02\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x24\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\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\x40\x20\x01\x01\x08\xc2\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x12\x02\x00\x88\x19\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\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\x08\x20\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\x04\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x12\x78\x08\xa2\xf2\xff\xff\x87\xd7\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x87\x06\x22\xfa\xff\x0b\x3f\x00\x00\x80\x80\x01\x10\x15\xce\xfc\x3f\xbc\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x87\x06\x22\xfa\xff\x8f\x3f\x38\x00\x80\xc0\x01\x10\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x1f\x7f\x70\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xe1\x07\x00\x00\x10\x30\x00\xa2\xc2\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x44\x85\x33\xff\x0f\xaf\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\x01\x01\x10\xfd\xfe\x84\x1f\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\x06\x04\x40\xf0\xe3\x13\x7e\x00\x00\x00\x00\x07\x22\x0a\x1c\xc1\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x51\xe1\xcc\xff\xc3\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x44\x85\x33\xff\x0f\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x87\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\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\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\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\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\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\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\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\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\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\x80\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x44\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x20\x00\x82\x1f\x9f\xf0\x03\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\x80\x80\x00\x08\x7e\x7c\xc2\x0f\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\x80\x01\x01\x10\xfc\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0f\x00\x00\x00\x00\x00\x00\x00\x03\x08\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\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\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\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x08\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x51\xf0\x7b\x06\x00\x20\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x08\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\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\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\x1c\x1a\x88\xe8\xff\x2f\xfe\xe0\x00\x00\x02\x07\x40\x54\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\xa8\x70\xe6\xff\xe1\xf5\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x70\x68\x20\xa2\xff\xbf\xf8\x83\x03\x00\x08\x1c\x20\x51\xe5\xcc\xff\xc3\xeb\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x07\x00\x10\x38\x00\xa3\xca\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xc2\x0f\x00\x00\x20\x60\x00\x44\x85\x33\xff\x0f\xaf\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\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x90\xc0\x43\x10\x15\xff\xff\x3f\xbc\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x00\x02\x07\x40\x54\x38\xf3\xff\xf0\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\x38\x34\x10\xd3\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\xa8\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x09\x3c\x04\x51\xf1\xff\xff\xc3\xeb\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\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\x1c\x1a\x88\xe8\xff\x2f\xfe\xe0\x00\x40\x02\x0f\x41\x54\xfe\xff\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x60\x40\x00\x44\xbf\x3f\xe1\x07\x00\x00\x00\x00\x00\xa2\xc6\x99\xff\x87\xd7\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\xfc\x9b\xaf\xfa\xff\x2f\xff\x57\x33\x08\x02\x07\x40\x54\x38\xf3\xff\xff\xfa\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\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\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\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\x02\x02\x20\xfa\xfd\x09\x3f\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x80\x01\x01\x10\xfc\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x02\x20\xf8\xf1\x09\x3f\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\x40\x00\x00\x00\x00\x01\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x48\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x10\x10\x00\xd1\xef\x4f\xf8\x01\x00\x00\x00\x00\x80\x28\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\x20\x20\x00\xa2\xdf\x9f\xf0\x03\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x10\x05\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\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\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\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\x04\x90\x10\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7f\x70\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x40\x02\x0f\x41\x54\xfc\xff\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x51\xf0\x3b\x06\x00\x20\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\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\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\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\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\x08\x08\x80\xe0\xc7\x27\xfc\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\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\x1c\x1a\x88\xe8\xff\x2f\xfe\xe0\x00\x00\x02\x07\x40\x54\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\xa8\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x51\xf0\x3b\x06\x00\x20\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\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\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\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\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\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\x01\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\x80\x80\x00\x00\x60\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x40\x00\x04\x3f\x3e\xe1\x07\x00\x00\x00\x00\x00\x20\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x10\x80\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x33\x20\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x04\x04\x40\xf4\xfb\x13\x7e\x00\x00\x00\x00\x00\x00\x02\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\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\x02\x02\x20\xfa\xfd\x09\x3f\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\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\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\x40\x40\x00\x44\xbf\x3f\xe1\x07\x00\x00\x00\x00\x00\x20\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x44\x85\x33\xff\x0f\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\x02\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\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\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\x04\x04\x40\xf4\xfb\x13\x7e\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\x08\x08\x80\xe8\xf7\x27\xfc\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\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\xc0\xa1\x81\x88\xfe\xff\xc2\x0f\x00\x00\x20\x60\x00\x44\x85\x33\xff\x0f\xaf\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\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\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\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\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\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\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\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\xe0\xdf\x7c\xd5\xff\x7f\xf9\xbf\x9a\x41\x10\x38\x00\xa2\xc2\x99\xff\xff\xd7\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\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\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x00\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\x02\x02\x20\xfa\xfd\x09\x3f\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\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\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\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\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\x04\x04\x40\xf4\xfb\x13\x7e\x00\x00\x00\x00\x00\x00\x02\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\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\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\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x00\x80\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x00\x00\x00\x00\x00\x02\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\x08\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\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x51\xf0\x7b\x06\x00\x20\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\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\x01\x01\x10\xfc\xf8\x84\x1f\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\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\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\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\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\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\x0c\x08\x80\xe0\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x8e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x51\xf0\x7b\x06\x04\x20\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\xa2\xe0\xf7\x0c\x08\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x40\x00\x04\x3f\x3e\xe1\x07\x00\x00\x00\x00\x00\x20\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\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\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\xa2\xe0\xf7\x0c\x00\x40\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\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\xa1\xb9\x88\xfe\xff\xf2\x7f\x04\x82\x20\x70\x00\x44\x85\x33\xff\xff\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x18\x00\x80\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x33\x20\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x90\x84\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\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\x80\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x51\xe1\xcc\xff\xc3\xeb\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\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\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\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\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\xa8\x72\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x87\x06\x22\xfa\xff\x8f\x3f\x38\x00\x80\xc0\x01\x10\x15\xce\xfc\x3f\xbc\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x51\xe1\xcc\xff\xc3\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x44\x85\x33\xff\x0f\xaf\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\x00\x00\x00\x00\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x20\x81\x87\x20\x2a\xfe\xff\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x20\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x00\x80\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\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\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\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\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x00\x80\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x70\xe0\x13\x7e\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\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\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x38\x00\x80\xc0\x01\x10\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xc0\xa1\x81\x98\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x44\x85\x33\xff\x0f\xaf\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\x80\x43\x03\x31\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\x88\x0a\x67\xfe\x1f\x5e\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x80\xc0\x01\x10\x15\xce\xfc\x3f\xbc\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\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x33\x20\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x07\x60\x00\x02\x78\x38\xa2\xe0\x77\x0c\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x01\x00\x00\x60\x00\x00\x00\x00\x00\x00\x20\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\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\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\x80\x5b\x73\x51\xfd\xff\xe5\xff\x08\x04\x41\xe0\x00\x88\x0a\x67\xfe\xff\x5f\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\xb7\xe6\xa2\xfa\xff\xcb\xff\x11\x08\x82\xc0\x01\x10\x15\xce\xfc\xff\xbf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x4b\x73\x55\xfd\xff\xe5\xff\x08\x04\x41\xe0\x00\x88\x0a\x67\xfe\xff\x5f\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\x97\xe6\xaa\xfa\xff\xcb\xff\x11\x08\x82\xc0\x01\x10\x15\xce\xfc\xff\xbf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x40\x00\x04\x3f\x3e\xe1\x07\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\x80\x01\x01\x10\xfc\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x00\x00\x00\x00\x00\x20\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\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\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\x08\x08\x80\xe8\xf7\x27\xfc\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\x20\x20\x00\xa2\xdf\x9f\xf0\x03\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\x0a\x48\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\xa8\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x43\x73\x11\xfd\xff\xe5\xff\x08\x04\x41\xe0\x00\x88\x0a\x67\xfe\xff\x5f\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\x87\xe6\x22\xfa\xff\xcb\xff\x11\x08\x82\xc0\x01\x10\x15\xce\xfc\xff\xbf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x3d\x03\x02\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\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\x00\x00\x10\x10\x00\xc1\x8f\x4f\xf8\x01\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\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\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\x0e\x0d\x44\xf4\xff\x17\x7f\x00\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x84\xe8\xd7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x8e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0e\x7e\xcf\x80\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x06\x04\x40\xf0\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x51\xf0\x7b\x06\x00\x20\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x00\x02\x07\x40\x54\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\xa8\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x51\xe1\xcc\xff\xc3\xeb\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\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\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\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\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\x04\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\x04\x04\x40\x70\xe0\x13\x7e\x00\x00\x00\x00\x00\x00\x00\x18\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\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\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\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\x80\x80\x00\xa9\x7e\x7f\xd2\x0f\x00\x00\x00\x00\x00\x40\x20\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x10\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x80\x84\x00\x00\x60\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\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x04\x04\x40\x70\xe0\x13\x7e\x00\x00\x00\x00\x00\x00\x00\x18\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\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xa2\xc2\x99\xff\x87\xd7\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x18\x20\x80\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\x01\x01\x10\xfc\xf8\x84\x1f\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\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\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\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\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7f\x04\x82\x20\x70\x00\x44\x85\x33\xff\xff\xaf\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\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x8e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x12\x02\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\x30\x20\x00\x82\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x51\xf0\x3b\x06\x00\x20\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\x97\xe6\xaa\xfa\xff\xcb\xff\x11\x08\x82\xc0\x01\x10\x15\xce\xfc\xff\xbf\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x06\xf0\x70\x44\xc1\xef\x18\x00\x80\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x0c\xe0\xe1\x88\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x02\x20\xf8\xf1\x09\x3f\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x40\x40\x00\x44\xbf\x3f\xe1\x07\x00\x00\x00\x00\x00\x20\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x00\x80\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\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\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\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\x80\x80\x00\x08\x7e\x7c\xc2\x0f\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\xa2\xe0\x77\x0c\x00\x40\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\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\x23\x0a\x7e\xcf\x80\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x60\x00\x02\x78\x38\xa2\xe0\xf7\x0c\x00\x40\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x00\x80\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\x20\x0a\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x14\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x28\x40\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x44\xc1\xef\x19\x10\x80\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x28\xf8\x1d\x03\x04\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x00\x03\x10\xc0\xc3\x11\x05\xbf\x63\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7f\x70\x00\x00\x81\x03\x20\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x10\x00\x00\x00\x82\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\x20\x20\x00\xaa\xdf\x9f\xf0\x03\x00\x80\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\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\x40\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\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\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\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\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\x02\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x60\x40\x00\x04\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\xa2\xe0\x77\x0c\x10\x40\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\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\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf2\x70\xc4\xe1\xef\x19\x00\x80\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\x04\x04\x40\xf0\xe3\x13\x7e\x00\x00\x00\x00\x00\x00\x02\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\x02\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\x88\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\x08\x80\xe0\xc7\x27\xfc\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\x30\x20\x00\x82\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x51\xf0\x3b\x06\x08\x20\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\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\x04\x04\x40\x70\xe0\x13\x7e\x00\x00\x00\x00\x00\x00\x00\x38\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\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\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\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\x02\xa0\xfa\xfd\x09\x3f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x08\x60\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\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\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#+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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc7\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\xc0\xbf\xf9\xaa\xff\xff\xf2\x7f\x35\x83\x20\x70\x00\x54\xe1\xcc\xff\xff\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x55\x38\xf3\xff\xf0\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\x38\x34\x17\xd1\xff\x5f\xfe\x8f\x40\x10\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\xfe\xe0\x00\x00\x02\x07\x40\x15\xce\xfc\x3f\xbc\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\x04\x04\x40\xf4\xfb\x13\x7e\x00\x00\x20\x80\x84\xa0\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\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x19\x00\x80\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\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\x40\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\x40\x40\x00\x44\xbf\x3f\xe1\x07\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x42\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\x80\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x60\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc1\x8f\x4f\xf8\x01\x00\x00\x00\x00\x00\x02\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x1c\x88\x0a\x1c\xc1\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x00\x00\x0e\x44\x05\x8e\x60\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x00\x00\x00\xc0\x81\xa8\xc0\x11\x0c\x00\x40\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\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2e\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x81\x3c\x1c\x1d\xfe\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x1a\x7f\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\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\x00\x00\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\x7e\x00\x00\x20\x80\x84\xa0\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\xc0\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x54\xe1\xcc\xff\xc3\xeb\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\x92\x10\x20\x08\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\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\x20\x20\x00\xa2\xdf\x9f\xf0\x03\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7f\x70\x00\x00\x81\x03\xa0\x0a\x67\xfe\x1f\x5e\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\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\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x50\x38\x20\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x1c\x1a\x88\xe8\xff\x2f\xfc\x00\x00\x00\x02\x06\x40\x15\xce\xfc\x3f\xbc\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\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\x87\x06\x22\xfa\xff\x0b\x3f\x00\x00\x80\x80\x01\x50\x85\x33\xff\x0f\xaf\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xf0\x03\x00\x00\x18\x18\x00\x55\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x5f\xfc\x01\x00\x00\x04\x0c\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x00\x02\x06\x40\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x17\x7e\x00\x00\x00\x01\x03\xa0\x0a\x67\xfe\x1f\x5e\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x90\xc0\x43\x70\xc5\xff\xff\x0f\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x48\xe1\x21\xe8\xf2\xff\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\xa4\xf0\x10\xd4\xf9\xff\xff\xc3\xeb\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\x60\x40\x00\x44\xbf\x3f\xe1\x07\x00\x00\x00\x00\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x00\x00\x00\x00\x00\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x38\x00\x80\xc0\x01\x50\x85\x33\xff\x0f\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x00\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x00\x20\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\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\x70\x68\x20\xa2\xff\xbf\xf8\x83\x03\x00\x08\x1c\x00\x55\x38\xf3\xff\xf0\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\x18\x10\x00\xd1\xef\x4f\xf8\x01\x00\x00\x00\x00\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x90\x10\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\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\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\xa8\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x02\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\x08\x08\x80\xe8\xf7\x27\xfc\x00\x00\x00\x00\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x90\xc2\x43\xd0\xe5\xff\xff\x0f\xaf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x0c\x90\x10\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x31\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x02\x00\x00\xc0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\xc1\xef\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x04\x04\x40\xf4\xfb\x13\x7e\x00\x00\x00\x00\x00\xa0\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\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\x01\x01\x10\xfd\xfe\x84\x1f\x00\x00\x00\x00\x00\xa8\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\x80\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x54\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\x40\x40\x80\x54\xbf\x3f\xe1\x07\x00\x00\x00\x00\x00\x2a\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x01\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\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\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\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\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\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\xc0\xa1\x81\x88\xfe\xff\xc2\x0f\x00\x00\x20\x60\x00\x54\xe1\xcc\xff\xc3\xeb\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0b\x3f\x00\x00\x80\x80\x01\x50\x85\x33\xff\x0f\xaf\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x90\x10\x20\x08\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\x80\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\x80\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\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\x08\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\x08\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\x01\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\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\x08\x08\x80\xe8\xf7\x27\xfc\x00\x00\x00\x00\x00\x04\x80\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\x00\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\x77\x0c\x00\x40\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\xc0\x80\x00\x08\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x3b\x06\x00\x20\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\x08\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x0c\x08\x80\xe0\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x63\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xf8\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x18\x00\x80\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x00\x02\x07\x40\x15\xce\xfc\x3f\xbc\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\xf7\x0c\x08\x40\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\xc0\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x00\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\x60\x40\x00\x04\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x60\x80\xfc\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\x02\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x00\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x12\x78\x08\xaa\xfc\xff\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x29\x3c\x04\x55\xfc\xff\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\x00\x00\x00\x02\x06\x40\x15\xce\xfc\x3f\xbc\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x04\x90\x10\x74\xc8\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\x80\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\x20\x20\x00\xa2\xdf\x9f\xf0\x03\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x04\x04\x40\xf4\xfb\x13\x7e\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x19\x00\x80\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\x01\x01\x10\xfd\xfe\x84\x1f\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\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\x70\x68\x2e\xa2\xff\xbf\xfc\x1f\x81\x20\x08\x1c\x00\x55\x38\xf3\xff\xff\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\x38\x34\x17\xd1\xff\x5f\xfe\x8f\x40\x10\x04\x0e\x80\x2a\x9c\xf9\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\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\x06\x04\x40\xf4\xe3\x13\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x33\x20\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x48\x42\x00\x40\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\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\x40\x20\x01\x01\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\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\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\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\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\x20\x80\x84\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\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\x02\x48\x08\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x48\xe0\x21\xa8\xf2\xff\xff\x87\xd7\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\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\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\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\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\x70\x68\x20\xa2\xff\xbf\xf0\x03\x00\x00\x08\x18\x00\x55\x38\xf3\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x70\x68\x20\xa2\xff\xff\xf8\x83\x03\x00\x08\x1c\x00\x55\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x7f\xfc\xc1\x01\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\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\x80\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\x43\x03\x11\xfd\xff\x85\x1f\x00\x00\x40\xc0\x00\xa8\xc2\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x54\xe1\xcc\xff\xc3\xeb\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\x40\x40\x00\x44\xbf\x3f\xe1\x07\x00\x00\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x1c\x88\x0a\x1c\xc1\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x80\xc0\x01\x50\x85\x33\xff\x0f\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x54\xe1\xcc\xff\xc3\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x60\x00\x02\x78\x38\x2a\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x1d\xfe\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x08\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\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\x02\x02\x20\xfa\xfd\x09\x3f\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\x80\x80\x00\x88\x7e\x7f\xc2\x0f\x00\x00\x00\x00\x00\x54\xc0\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\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\x02\x02\x20\xf8\xf1\x09\x3f\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\x80\x80\x00\x08\x7e\x7c\xc2\x0f\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\x60\x40\x00\x04\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x67\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x80\x00\x08\x0e\x7c\xc2\x0f\x00\x00\x00\x00\x00\x00\xc0\x00\x02\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x60\x00\x02\x78\x38\x2a\xf8\x3d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x33\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x19\x00\x80\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1c\x1a\x88\xe8\xff\x2f\xfe\xe0\x00\x00\x02\x07\x40\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\xa0\x0a\x67\xfe\x1f\x5e\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x80\xc0\x01\x52\x95\x33\xff\x0f\xaf\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x1c\x00\x40\xe0\x00\xac\xca\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xc2\x0f\x00\x00\x20\x60\x00\x54\xe1\xcc\xff\xc3\xeb\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x09\x3c\x04\x55\xfc\xff\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x00\x02\x07\x40\x15\xce\xfc\x3f\xbc\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\x0e\x0d\xc4\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\xa0\x0a\x67\xfe\x1f\x5e\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x90\xc0\x43\x50\xc5\xff\xff\x0f\xaf\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\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\x1c\x1a\x88\xe8\xff\x2f\xfe\xe0\x00\x40\x02\x0f\x41\x95\xff\xff\x3f\xbc\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\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\x80\x01\x01\x10\xfd\xfe\x84\x1f\x00\x00\x00\x00\x00\xa8\xc6\x99\xff\x87\xd7\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\xfc\x9b\xaf\xfa\xff\x2f\xff\x57\x33\x08\x02\x07\x40\x15\xce\xfc\xff\xbf\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\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\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\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\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\x20\x20\x00\xa2\xdf\x9f\xf0\x03\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\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\x04\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\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\x60\x40\x00\x04\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\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\x01\x00\x00\x00\x01\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\x20\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\x18\x20\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\x04\x04\x40\xf4\xfb\x13\x7e\x00\x00\x00\x00\x00\xa0\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\x02\x02\x20\xfa\xfd\x09\x3f\x00\x00\x00\x00\x00\x50\x01\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x15\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\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\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\x04\x90\x10\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\x00\x00\x00\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x40\x02\x0f\x41\x15\xff\xff\x3f\xbc\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\x08\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x18\x00\x80\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\x10\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\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\x80\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\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\x1c\x1a\x88\xe8\xff\x2f\xfe\xe0\x00\x00\x02\x07\x40\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\xa0\x0a\x67\xfe\x1f\x5e\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\x03\x02\x20\xf8\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x18\x00\x80\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\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\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\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\x80\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\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\x10\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\x80\x00\x02\x02\x00\x60\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x01\x10\xfc\xf8\x84\x1f\x00\x00\x00\x00\x00\x20\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x04\x20\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x3d\x03\x02\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\x10\x00\xd1\xef\x4f\xf8\x01\x00\x00\x00\x00\x00\x02\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x07\x00\x00\x00\x00\x00\x08\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\x20\x20\x00\xa2\xdf\x9f\xf0\x03\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\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\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\x01\x01\x10\xfd\xfe\x84\x1f\x00\x00\x00\x00\x00\x20\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x54\xe1\xcc\xff\xc3\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x10\x00\xd1\xef\x4f\xf8\x01\x00\x00\x00\x00\x80\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\x08\x08\x80\xe8\xf7\x27\xfc\x00\x00\x00\x00\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x00\x00\x00\x00\x00\xa8\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\xc0\xa1\x81\x88\xfe\xff\xc2\x0f\x00\x00\x20\x60\x00\x54\xe1\xcc\xff\xc3\xeb\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\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\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\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\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\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\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\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\x7f\xf3\x55\xff\xff\xe5\xff\x6a\x06\x41\xe0\x00\xa8\xc2\x99\xff\xff\xd7\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\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\x02\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\x01\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\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\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x00\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\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\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\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\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\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\x10\x00\xd1\xef\x4f\xf8\x01\x00\x00\x00\x00\x00\x02\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\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\x40\x40\x00\x44\xbf\x3f\xe1\x07\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x00\x20\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\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc1\x8f\x4f\xf8\x01\x00\x00\x00\x00\x00\x02\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\x02\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\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x19\x00\x80\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\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\x40\x40\x00\x04\x3f\x3e\xe1\x07\x00\x00\x00\x01\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x08\x80\xe0\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x63\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x02\x20\xfa\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x19\x10\x80\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\xf7\x0c\x08\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x01\x01\x10\xfc\xf8\x84\x1f\x00\x00\x00\x00\x00\x20\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\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\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\xf7\x0c\x00\x40\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\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\xa1\xb9\x88\xfe\xff\xf2\x7f\x04\x82\x20\x70\x00\x54\xe1\xcc\xff\xff\xeb\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\xe0\xd0\x40\x44\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\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\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\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\xc0\x80\x00\x08\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x3b\x06\x00\x20\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x3d\x03\x02\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x12\x02\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\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\x80\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x38\x00\x80\xc0\x01\x50\x85\x33\xff\x0f\xaf\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\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\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\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\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\xa0\x2a\x67\xfe\x1f\x5e\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\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\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\x70\x68\x20\xa2\xff\xff\xf8\x83\x03\x00\x08\x1c\x00\x55\x38\xf3\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x38\x00\x80\xc0\x01\x50\x85\x33\xff\x0f\xaf\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\xc0\xa1\x81\x88\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x54\xe1\xcc\xff\xc3\xeb\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x80\x04\x1e\x82\x2a\xfe\xff\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x00\x20\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\x00\x00\x00\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x00\x20\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x00\x20\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc1\x81\x4f\xf8\x01\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\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\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\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\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\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\x40\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x70\x68\x20\xa2\xff\xbf\xf8\x83\x03\x00\x08\x1c\x00\x55\x38\xf3\xff\xf0\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\x38\x34\x10\xd1\xff\x5f\xfc\xc1\x01\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xc0\xa1\x81\x98\xfe\xff\xe2\x0f\x0e\x00\x20\x70\x00\x54\xe1\xcc\xff\xc3\xeb\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\xe0\xd0\x40\x4c\xff\x7f\xf1\x07\x07\x00\x10\x38\x00\xaa\x70\xe6\xff\xe1\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x83\x03\x00\x08\x1c\x00\x55\x38\xf3\xff\xf0\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x3d\x03\x02\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\x01\x01\x10\xfc\xf8\x84\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\x77\x0c\x00\x40\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x04\x00\x00\x80\x01\x00\x00\x00\x00\x00\x20\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\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\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\x30\x20\x00\xa2\x1f\x9f\xf0\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x01\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\xe0\xd6\x5c\x54\xff\x7f\xf9\x3f\x02\x41\x10\x38\x00\xaa\x70\xe6\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x81\x20\x08\x1c\x00\x55\x38\xf3\xff\xff\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x02\x41\x10\x38\x00\xaa\x70\xe6\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x81\x20\x08\x1c\x00\x55\x38\xf3\xff\xff\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x01\x10\xfc\xf8\x84\x1f\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\x60\x40\x00\x04\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x15\xfc\x9e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x00\x00\x00\x00\x00\x20\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\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\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\x08\x08\x80\xe8\xf7\x27\xfc\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\x02\x02\x20\xfa\xfd\x09\x3f\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\x28\x20\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\xa0\x0a\x67\xfe\x1f\x5e\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\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\xe0\xd0\x5c\x44\xff\x7f\xf9\x3f\x02\x41\x10\x38\x00\xaa\x70\xe6\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x2e\xa2\xff\xbf\xfc\x1f\x81\x20\x08\x1c\x00\x55\x38\xf3\xff\xff\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x33\x20\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x04\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\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\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\x04\x04\x40\xf0\xe3\x13\x7e\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x38\x34\x10\xd1\xff\x5f\xfc\x01\x00\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x84\xe8\xd7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x63\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\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\x15\x20\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\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\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\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0e\x7e\xcf\x80\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x18\x10\x00\xc1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x19\x00\x80\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfe\xe0\x00\x00\x02\x07\x40\x15\xce\xfc\x3f\xbc\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\x0e\x0d\x44\xf4\xff\x17\x7f\x70\x00\x00\x81\x03\xa0\x0a\x67\xfe\x1f\x5e\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\x87\x06\x22\xfa\xff\x8b\x3f\x38\x00\x80\xc0\x01\x50\x85\x33\xff\x0f\xaf\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\x10\x00\xc1\x81\x4f\xf8\x01\x00\x00\x00\x00\x00\x00\x18\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\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\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\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\x80\x80\x00\xa9\x7e\x7f\xd2\x0f\x00\x00\x00\x00\x00\x10\xc8\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\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\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\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\x00\x80\x00\x12\x02\x00\x60\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\x40\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\x08\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc1\x81\x4f\xf8\x01\x00\x00\x00\x00\x00\x00\x18\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\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\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\x80\x43\x03\x11\xfd\xff\xc5\x1f\x1c\x00\x40\xe0\x00\xa8\xc2\x99\xff\x87\xd7\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\x80\x00\x08\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x3b\x06\x08\x20\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\x40\x40\x00\x04\x3f\x3e\xe1\x07\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\xc0\xad\xb9\xa8\xfe\xff\xf2\x7f\x04\x82\x20\x70\x00\x54\xe1\xcc\xff\xff\xeb\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\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x63\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x84\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\x03\x02\x20\xf8\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x18\x00\x80\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\x70\x69\xae\xaa\xff\xbf\xfc\x1f\x81\x20\x08\x1c\x00\x55\x38\xf3\xff\xff\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xc7\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x06\xf0\x70\x54\xf0\x3b\x06\x00\x20\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x03\x78\x38\x2a\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xcf\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\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\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\x01\x01\x10\xfd\xfe\x84\x1f\x00\x00\x00\x00\x00\x20\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x00\x20\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\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\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\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\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\x40\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\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\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\x80\x80\x00\x08\x7e\x7c\xc2\x0f\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\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\x80\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x80\x01\x01\x10\xfd\xf8\x84\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\x77\x0c\x00\x40\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\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\x18\x10\x00\xd1\x8f\x4f\xf8\x01\x18\x80\x00\x1e\x8e\x0a\x7e\xcf\x80\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\xf7\x0c\x00\x40\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x00\x20\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\x80\x0a\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\x0c\x08\x80\xe8\xc7\x27\xfc\x00\x0c\x40\x00\x0f\x47\x05\xbf\x67\x40\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0f\xc0\x00\x04\xf0\x70\x54\xf0\x7b\x06\x04\x20\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\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\x06\x04\x40\xf0\xe3\x13\x7e\x00\x06\x20\x80\x87\xa3\x82\xdf\x31\x40\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03\x30\x00\x01\x3c\x1c\x15\xfc\x8e\x01\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc1\x01\x00\x04\x0e\x80\x2a\x9c\xf9\x7f\x78\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x01\x00\x00\x08\x82\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\x02\x02\xa0\xfa\xfd\x09\x3f\x00\x00\x08\x00\x00\x40\x00\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\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\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x20\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x80\x01\x01\x10\xfc\xf8\x84\x1f\x80\x01\x08\xe0\xe1\xa8\xe0\x77\x0c\x10\x40\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\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\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\xc0\x80\x00\x88\x7e\x7c\xc2\x0f\xc0\x00\x04\xf2\x70\x74\xf8\x7b\x06\x00\x20\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\x10\x10\x00\xc1\x8f\x4f\xf8\x01\x00\x00\x00\x00\x00\x02\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\x20\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\x60\x40\x00\x44\x3f\x3e\xe1\x07\x60\x00\x02\x78\x38\x2a\xf8\x1d\x03\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\x80\xe0\xc7\x27\xfc\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\x03\x02\x20\xf8\xf1\x09\x3f\x00\x03\x10\xc0\xc3\x51\xc1\xef\x18\x20\x80\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\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\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\x10\x10\x00\xc1\x81\x4f\xf8\x01\x00\x00\x00\x00\x00\x00\x38\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\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\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\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x20\x00\xaa\xdf\x9f\xf0\x03\x00\x80\x00\x00\x00\x04\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\x04\x04\x48\xf5\xfb\x93\x7e\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\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\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\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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","standalone_kind_sig","sks_vars","inst_decl","overlap_pragma","deriv_strategy_no_via","deriv_strategy_via","deriv_standalone_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","tycl_hdr_inst","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_activation_marker","rule_explicit_activation","rule_foralls","rule_vars","rule_var","warnings","warning","deprecations","deprecation","strings","stringlist","annotation","fdecl","callconv","safety","fspec","opt_sig","opt_tyconsig","sigtype","sigtypedoc","sig_vars","sigtypes1","unpackedness","forall_vis_flag","ktype","ktypedoc","ctype","ctypedoc","context","constr_context","type","typedoc","constr_btype","constr_tyapps","constr_tyapp","btype","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","deriv_clause_types","docdecl","docdecld","decl_no_th","decl","rhs","gdrhs","gdrh","sigdecl","activation","explicit_activation","quasiquote","exp","infixexp","exp10p","exp10","optSemi","prag_e","fexp","aexp","aexp1","aexp2","splice_exp","splice_untyped","splice_typed","cmdargs","acmd","cvtopbody","cvtopdecls0","texp","tup_exprs","commas_tup_tail","tup_tail","list","lexps","flattenedpquals","pquals","squals","transformqual","guardquals","guardquals1","altslist","alts","alts1","alt","alt_rhs","ralt","gdpats","ifgdpats","gdpat","pat","bindpat","apat","apats","stmtlist","stmts","maybe_stmt","e_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","exp_prag__exp__","exp_prag__exp10p__","'_'","'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'","'via'","'unit'","'signature'","'dependency'","'{-# INLINE'","'{-# SPECIALISE'","'{-# SPECIALISE_INLINE'","'{-# SOURCE'","'{-# RULES'","'{-# CORE'","'{-# SCC'","'{-# GENERATED'","'{-# DEPRECATED'","'{-# WARNING'","'{-# UNPACK'","'{-# NOUNPACK'","'{-# ANN'","'{-# MINIMAL'","'{-# CTYPE'","'{-# OVERLAPPING'","'{-# OVERLAPPABLE'","'{-# OVERLAPS'","'{-# INCOHERENT'","'{-# COMPLETE'","'#-}'","'..'","':'","'::'","'='","'\\\\'","'lcase'","'|'","'<-'","'->'","TIGHT_INFIX_AT","'=>'","'-'","PREFIX_TILDE","PREFIX_BANG","'*'","'-<'","'>-'","'-<<'","'>>-'","'.'","PREFIX_AT","'{'","'}'","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|'","'|]'","'[||'","'||]'","PREFIX_DOLLAR","PREFIX_DOLLAR_DOLLAR","TH_TY_QUOTE","TH_QUASIQUOTE","TH_QQUASIQUOTE","%eof"]-        bit_start = st * 481-        bit_end = (st + 1) * 481+  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","standalone_kind_sig","sks_vars","inst_decl","overlap_pragma","deriv_strategy_no_via","deriv_strategy_via","deriv_standalone_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","tycl_hdr_inst","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_activation_marker","rule_explicit_activation","rule_foralls","rule_vars","rule_var","warnings","warning","deprecations","deprecation","strings","stringlist","annotation","fdecl","callconv","safety","fspec","opt_sig","opt_tyconsig","sigtype","sigtypedoc","sig_vars","sigtypes1","unpackedness","forall_vis_flag","ktype","ktypedoc","ctype","ctypedoc","context","constr_context","type","typedoc","constr_btype","constr_tyapps","constr_tyapp","btype","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","deriv_clause_types","docdecl","docdecld","decl_no_th","decl","rhs","gdrhs","gdrh","sigdecl","activation","explicit_activation","quasiquote","exp","infixexp","exp10p","exp10","optSemi","prag_e","fexp","aexp","aexp1","aexp2","splice_exp","splice_untyped","splice_typed","cmdargs","acmd","cvtopbody","cvtopdecls0","texp","tup_exprs","commas_tup_tail","tup_tail","list","lexps","flattenedpquals","pquals","squals","transformqual","guardquals","guardquals1","altslist","alts","alts1","alt","alt_rhs","ralt","gdpats","ifgdpats","gdpat","pat","bindpat","apat","apats","stmtlist","stmts","maybe_stmt","e_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","exp_prag__exp__","exp_prag__exp10p__","'_'","'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'","'via'","'unit'","'signature'","'dependency'","'{-# INLINE'","'{-# SPECIALISE'","'{-# SPECIALISE_INLINE'","'{-# SOURCE'","'{-# RULES'","'{-# CORE'","'{-# SCC'","'{-# GENERATED'","'{-# DEPRECATED'","'{-# WARNING'","'{-# UNPACK'","'{-# NOUNPACK'","'{-# ANN'","'{-# MINIMAL'","'{-# CTYPE'","'{-# OVERLAPPING'","'{-# OVERLAPPABLE'","'{-# OVERLAPS'","'{-# INCOHERENT'","'{-# COMPLETE'","'#-}'","'..'","':'","'::'","'='","'\\\\'","'lcase'","'|'","'<-'","'->'","TIGHT_INFIX_AT","'=>'","'-'","PREFIX_TILDE","PREFIX_BANG","'*'","'-<'","'>-'","'-<<'","'>>-'","'.'","PREFIX_AT","'{'","'}'","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|'","'|]'","'[||'","'||]'","PREFIX_DOLLAR","PREFIX_DOLLAR_DOLLAR","TH_TY_QUOTE","TH_QUASIQUOTE","TH_QQUASIQUOTE","%eof"]+        bit_start = st * 479+        bit_end = (st + 1) * 479         read_bit = readArrayBit happyExpList         bits = map read_bit [bit_start..bit_end - 1]-        bits_indexed = zip bits [0..480]+        bits_indexed = zip bits [0..478]         token_strs_expected = concatMap f bits_indexed         f (False, _) = []         f (True, nr) = [token_strs !! nr]  happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\x44\x00\xd7\x00\xa1\x00\xf0\x25\x38\x1a\xde\x28\xde\x28\x2e\x24\xf0\x25\xf6\x42\xb0\x39\x72\x00\x42\x00\xde\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\x00\x00\x00\x00\x0a\x01\x00\x00\x76\x01\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x85\x01\x85\x01\x00\x00\x2b\x01\x8e\x01\xb5\x01\x00\x00\x36\x02\xa0\x40\x00\x00\x00\x00\x00\x00\x00\x00\x45\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\xfc\x59\x00\x00\x00\x00\x00\x00\x4f\x02\x5b\x02\x00\x00\x00\x00\x1b\x41\x1b\x41\x00\x00\x00\x00\x1b\x41\x76\x00\xab\x34\xa7\x32\x28\x33\x78\x56\xc1\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x32\x00\x00\x00\x00\x42\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\x88\x02\x23\x09\x75\x01\xdd\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x02\x84\x06\x00\x00\xde\x28\xba\x2e\x00\x00\xad\x02\x00\x00\x00\x00\x00\x00\xcc\x02\xa6\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x02\x00\x00\x00\x00\x00\x00\xde\x28\x49\x04\xc4\x24\xa8\x04\xc4\x04\x12\x31\xc4\x04\x12\x31\xd0\x02\x38\x02\x2b\x03\x50\x2f\xe6\x2f\x12\x31\x12\x31\xaa\x20\x26\x1d\xbc\x1d\x20\x32\x3c\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x28\x24\x2e\xb0\x39\xde\x04\xde\x28\x20\x32\x14\x56\x39\x03\x00\x00\x2e\x03\x79\x03\x50\x03\x76\x03\x00\x00\x00\x00\x00\x00\xe7\x04\xbb\x02\x8c\x03\x53\x00\x8c\x03\xde\x56\x9c\x57\xbb\x02\x52\x1e\x00\x00\x75\x03\x75\x03\x75\x03\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\x8c\x07\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x40\x03\x04\xc2\x03\xba\x02\x4f\x05\x00\x00\x26\x35\x90\x00\xd7\x57\xc4\x03\x04\x58\x04\x58\x6f\x57\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x03\x00\x00\xbb\x03\x2a\x04\xe9\x03\x37\x04\xf8\x03\xa5\x04\x00\x00\x00\x00\x00\x00\x4b\x04\x46\x04\x68\x00\xff\x01\xff\x01\xb5\x04\x9b\x04\x12\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x31\x89\x04\x09\x04\x33\x00\x00\x00\x8e\x00\x92\x04\x47\x00\x00\x00\x8e\x00\x60\x00\x00\x00\xa3\x04\x21\x02\x02\x59\xc6\x04\xc4\x00\xe3\x02\x00\x00\xf2\x05\xf2\x05\x22\x01\xc8\x04\xd6\x04\x84\x01\xb0\x3c\xa0\x40\xbe\x02\xb0\x39\xe4\x04\xef\x04\x07\x05\x0c\x05\x00\x00\x31\x05\x00\x00\x00\x00\x00\x00\xa0\x40\xb0\x39\xa0\x40\xf3\x04\x16\x05\x00\x00\xf1\x03\x00\x00\xde\x28\x00\x00\x00\x00\xa7\x35\xd6\x54\xa0\x40\x61\x05\x11\x05\x5d\x05\x84\x06\x8c\x01\x57\x05\x00\x00\x24\x2e\x00\x00\x00\x00\x00\x00\x8b\x05\x8e\x05\x91\x05\x9c\x05\x7e\x1f\x40\x21\x00\x00\xe6\x2f\x00\x00\x00\x00\xd6\x54\xa1\x05\xbe\x05\xdd\x05\x00\x00\xe1\x05\x00\x00\xce\x05\x00\x00\x0b\x57\x32\x00\xde\x56\x00\x00\x58\x01\xde\x56\xb0\x39\xde\x56\x00\x00\x34\x06\xe8\x1e\xe8\x1e\x48\x59\x28\x36\xec\x04\x00\x00\x00\x00\x00\x00\x00\x00\xde\x05\x84\x05\x33\x02\x00\x00\x00\x00\xd0\x05\xd3\x05\x00\x00\x00\x00\xd9\x05\xfa\x04\xdc\x05\x00\x00\x00\x00\xb6\x09\x00\x00\x43\x02\xfd\x05\x00\x00\x00\x00\x14\x20\x00\x00\x05\x06\x98\x01\x0a\x06\x03\x06\x00\x00\x00\x00\x00\x00\x7c\x30\x00\x00\x12\x31\xf2\x04\xf5\x05\x2e\x06\x33\x06\x39\x06\x00\x00\x00\x00\xf0\x25\xf0\x25\x2b\x06\x00\x00\x78\x06\x17\x06\x58\x00\x00\x00\x00\x00\x74\x29\x35\x06\x00\x00\x73\x06\x12\x31\x0a\x2a\xa5\x56\x00\x00\x1b\x41\x00\x00\xb0\x39\x0a\x2a\x0a\x2a\x0a\x2a\x0a\x2a\x1c\x06\x1d\x06\x85\x02\x25\x06\x26\x06\x7b\x00\x27\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x39\xa9\x33\x41\x56\x22\x06\x28\x06\x24\x00\x2a\x06\x2f\x06\x47\x03\x00\x00\xd4\x00\x2d\x06\x27\x01\x30\x06\x00\x00\x2a\x01\x00\x00\x3a\x06\x00\x00\xbf\x00\x00\x00\x48\x59\x00\x00\xb0\x55\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x02\xfc\x59\x00\x00\x4d\x32\xa0\x40\x00\x00\xb0\x39\xb0\x39\xb0\x39\x8b\x01\x00\x00\xf9\x41\x56\x00\x00\x00\x3b\x06\x00\x00\x71\x03\x71\x03\x57\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x91\x06\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x06\x8a\x06\x4d\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x06\x00\x00\xb0\x39\x00\x00\x00\x00\x87\x01\x00\x00\xf6\x01\x3d\x06\x00\x00\x00\x00\xb0\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x39\x00\x00\x00\x00\x00\x00\xb0\x39\xb0\x39\x00\x00\x00\x00\x3f\x06\x3e\x06\x48\x06\x4a\x06\x4b\x06\x53\x06\x56\x06\x57\x06\x59\x06\x5e\x06\x63\x06\x65\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\x67\x06\x00\x00\x66\x06\x7e\x06\x00\x00\x00\x00\x00\x00\xf2\x04\x27\x02\x81\x06\x68\x06\x00\x00\x00\x00\x00\x00\xc0\x06\x00\x00\x0a\x2a\x0a\x2a\x75\x00\x00\x00\x94\x02\x00\x00\x00\x00\x00\x00\x8c\x06\x00\x00\x5a\x25\xa2\x19\x12\x31\x88\x06\x98\x23\x00\x00\x0a\x2a\x86\x26\x98\x23\x00\x00\x74\x06\x00\x00\x00\x00\x00\x00\xd6\x21\x95\x06\x00\x00\x99\x31\x00\x00\x00\x00\x00\x00\x00\x00\x38\x1a\x68\x00\x86\x06\x00\x00\x00\x00\x00\x00\x7f\x06\x00\x00\x7d\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x58\x00\x00\x00\x00\xa1\x06\x00\x00\x37\x00\xaa\x06\xa0\x40\xfc\x59\xaa\x01\x86\x00\x00\x00\x00\x00\x3f\x08\x00\x00\x6c\x22\x02\x23\x62\x01\x00\x00\xac\x06\xe1\x02\xf8\x02\xb1\x06\x00\x00\xb4\x06\xb2\x06\x82\x06\x00\x00\x00\x00\x9c\x06\xb5\x06\x00\x00\xb9\x06\x9b\x06\x9d\x06\x3f\x58\x3f\x58\x00\x00\xbe\x06\xbf\x03\xbb\x02\x99\x06\x9e\x06\xbf\x06\x00\x00\x96\x06\xf0\x09\x00\x00\x00\x00\x0a\x2a\x98\x23\x5e\x00\x31\x3d\x2a\x00\x00\x00\xba\x06\x1c\x00\xc4\x06\xfc\x59\x00\x00\x00\x00\x0a\x2a\x00\x00\x00\x00\x54\x00\x00\x00\x0a\x2a\xa0\x2a\xa0\x40\xfa\x06\x00\x00\xc7\x06\xae\x06\x00\x00\x4f\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x5d\x00\x82\x04\x9d\x03\x00\x00\xcc\x06\xfc\x59\x28\x36\x28\x36\xbe\x02\x3c\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x41\xc6\x31\xa8\x06\x28\x36\x00\x00\xc6\x31\x48\x59\x36\x2b\x36\x2b\x03\x07\x00\x00\x7e\x01\x00\x00\xa0\x06\x00\x00\xa6\x06\x00\x00\x00\x00\x6c\x58\x6c\x58\x00\x00\x00\x00\x6c\x58\x12\x31\xd4\x06\xda\x06\x00\x00\x10\x07\x00\x00\xbe\x03\xbe\x03\x00\x00\x00\x00\x00\x00\x20\x07\x00\x00\xc1\x06\x00\x00\x38\x1a\xc6\x06\x8e\x00\x8e\x00\xc6\x06\xaf\x06\x00\x00\x00\x00\x00\x00\xe7\x06\x00\x00\x00\x00\x00\x00\xeb\x02\x00\x00\x00\x00\x1d\x01\xce\x06\x24\x2e\x75\x59\x1d\x07\x00\x00\xd5\x06\xd3\x06\x00\x00\x00\x00\xd6\x06\x00\x00\xcc\x41\x00\x00\xf8\x06\xfb\x06\xfe\x06\x01\x07\xa2\x59\x00\x00\x00\x00\x00\x00\x02\x07\x00\x00\xef\x06\xb0\x39\x07\x07\xb0\x39\xfc\x59\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x04\xb0\x39\x00\x00\x00\x00\xb0\x39\xeb\x06\x00\x00\x29\x5a\x00\x00\x19\x05\x00\x00\x0d\x07\x44\x07\x00\x00\x00\x00\x1d\x05\x00\x00\xe6\x02\xa0\x40\x0f\x07\xa9\x36\xa9\x36\x4b\x07\x5f\x07\x1e\x07\xb0\x39\x2a\x00\x19\x07\x00\x00\x62\x5a\x00\x00\x28\x07\x00\x00\x00\x00\x25\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x39\x00\x00\x13\x07\xb0\x39\x00\x00\x00\x00\x00\x00\xff\x06\x00\x00\xe8\x1e\x36\x2b\x00\x00\x00\x00\x2a\x37\xa2\x59\xe6\x02\x29\x07\xa0\x40\x2a\x37\x2a\x37\xec\x04\x00\x00\x00\x00\x11\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x01\x00\x00\x00\x00\x00\x00\x5f\x01\x00\x00\x00\x00\xcc\x2b\x00\x00\x00\x00\x62\x2c\x00\x00\x68\x00\x14\x07\x00\x00\xe4\x03\x00\x00\x1c\x27\x1c\x07\x00\x00\x06\x07\x00\x00\xb2\x27\x00\x00\x00\x00\x00\x00\x62\x2c\xf8\x2c\x8e\x2d\x00\x00\x00\x00\x98\x23\xa5\x56\x00\x00\x00\x00\x00\x00\xb0\x39\x00\x00\x00\x00\x2d\x07\x00\x00\x18\x07\x21\x07\x04\x07\xb0\x39\x00\x00\xb0\x39\xd4\x58\x46\x05\x00\x00\x22\x07\x22\x07\x6d\x07\x18\x03\x70\x07\x00\x00\x30\x00\x30\x00\x00\x00\x27\x07\x0a\x07\x00\x00\x0c\x07\x00\x00\x00\x00\x2a\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x07\x00\x00\x3e\x07\x00\x00\x00\x00\x00\x00\x7e\x07\x48\x07\x8e\x2d\x8e\x2d\x00\x00\x00\x00\x6e\x07\xeb\x03\x48\x28\x48\x28\x8e\x2d\x2f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x37\x2a\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x07\x30\x07\x54\x07\x00\x00\x56\x07\x00\x00\x47\x07\xa0\x40\x8e\x07\xa1\x07\x00\x00\x2b\x07\x00\x00\xa7\x07\x00\x00\xde\x02\xa7\x07\x49\x05\x2a\x37\x53\x04\xab\x37\x00\x00\x00\x00\x8e\x2d\x00\x00\xce\x1a\xce\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x1b\x64\x1b\x00\x00\x00\x00\x00\x00\x96\x07\x4d\x32\x00\x00\xa0\x40\xb0\x39\x63\x07\x2c\x38\x00\x00\x00\x00\xa2\x59\x00\x00\x00\x00\x4d\x05\x55\x07\xcf\x59\x00\x00\xc6\x31\x70\x0c\x00\x00\x00\x00\x50\x07\x00\x00\x3a\x07\x00\x00\x71\x03\x00\x00\xa0\x07\x76\x07\x77\x07\xaa\x07\x58\x07\x00\x00\xcb\x05\x00\x00\x00\x00\xcb\x05\xae\x07\x00\x00\x00\x00\x8e\x2d\x7c\x07\x00\x00\xb4\x07\xe8\x1e\xe8\x1e\x00\x00\x00\x00\x2c\x38\x00\x00\x80\x07\x00\x00\x7d\x07\x00\x00\xcf\x05\x00\x00\xbf\x07\x00\x00\x7c\x01\x00\x00\x00\x00\xbf\x07\x07\x03\x00\x00\x4d\x32\x00\x00\x00\x00\x95\x01\x00\x00\xaf\x07\x24\x2e\xae\x38\x13\x03\x00\x00\x00\x00\x00\x00\x88\x05\x88\x05\x00\x00\xec\x02\xa9\x07\x4c\x07\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x34\x00\x00\x1a\x00\x00\x00\xc3\x07\x00\x00\xd8\x07\x00\x00\xa0\x40\x00\x00\x00\x00\xb0\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x2d\x8e\x2d\x8e\x2d\x00\x00\x00\x00\x00\x00\x61\x07\xd9\x07\x00\x00\x00\x00\x00\x00\x00\x00\xac\x01\x00\x00\x0f\x02\x26\x42\x29\x03\xda\x05\x7a\x07\x00\x00\x03\x55\x18\x03\x00\x00\x00\x00\x00\x00\xda\x05\x00\x00\x00\x00\x00\x00\x00\x00\x18\x03\x7f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x71\x03\x04\x03\xc3\x04\x93\x08\x18\x03\x00\x00\x00\x00\x00\x00\x46\x00\x83\x07\x82\x07\x53\x42\xab\x07\x71\x03\x00\x00\x8e\x2d\xa2\x07\x00\x00\x00\x00\xc0\x07\x00\x00\x97\x07\x00\x00\x00\x00\xac\x3d\x62\x5a\x9e\x07\x81\x07\x88\x07\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x86\x07\x00\x00\xa8\x07\x8a\x07\x98\x07\x00\x00\xfa\x1b\x00\x00\x4d\x04\x2d\x3e\xa0\x40\x67\x0b\xa0\x40\x00\x00\x00\x00\x00\x00\x90\x1c\x2d\x3e\x00\x00\x00\x00\xb6\x07\x00\x00\x31\x3a\xb2\x3a\x4d\x32\x33\x3b\x00\x00\xbc\x01\x2f\x03\xcf\x59\x33\x3b\x00\x00\xfa\x07\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x9d\x07\x65\x00\x71\x03\x99\x07\xa5\x07\x00\x00\x00\x00\x00\x00\x4d\x32\x00\x00\xce\x01\x00\x00\x68\x00\x42\x03\xa6\x07\xae\x3e\x00\x00\x00\x00\xb2\x07\x2f\x39\x76\x04\x00\x00\x00\x00\x33\x3b\xb4\x3b\x00\x00\x00\x00\xbb\x02\x2f\x39\x88\x05\x00\x00\x00\x00\x2f\x39\x84\x07\xac\x07\xb3\x07\x00\x00\x2f\x3c\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x40\x8e\x2d\x8b\x07\x00\x00\x50\x00\x71\x03\x00\x00\x71\x03\x00\x00\x71\x03\x00\x00\x00\x00\xa3\x07\xa4\x07\xad\x07\x00\x00\x18\x02\x00\x00\x00\x00\x00\x00\x77\x55\xb0\x07\x00\x00\x00\x00\x18\x03\xb5\x07\xb8\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x05\x08\x11\x03\x00\x00\x66\x00\x50\x00\xb9\x07\xc9\x07\x00\x00\x00\x00\x00\x00\x29\x3f\x00\x00\x8f\x07\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x07\xc7\x07\xa7\x32\x00\x00\x00\x00\x62\x5a\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\xaa\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x07\x18\x03\x00\x00\x00\x00\xb7\x07\x18\x03\x00\x00\x03\x08\x16\x08\xdb\x07\x4d\x32\x00\x00\x25\x40\x00\x00\x00\x00\x11\x08\xcf\x07\x06\x10\x71\x03\x00\x00\x71\x03\x71\x03\x00\x00\x71\x03\x77\x55\x00\x00\x00\x00\x45\x45\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x07\xed\x07\x00\x00\x71\x03\x2b\x08\xf7\x05\x00\x00\x00\x00\x3e\x08\xdc\x07\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\xd2\x07\x71\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#+happyActOffsets = HappyA# "\x4b\x00\xe1\xff\x97\x00\xc6\x25\x36\x1a\xaa\x28\xaa\x28\x0a\x24\xc6\x25\x42\x54\x3e\x39\x8a\x00\x44\x00\x2e\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x02\x00\x00\x00\x00\x78\x00\x00\x00\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x33\x01\x33\x01\x00\x00\x01\x01\x6b\x01\x5a\x01\x00\x00\xc4\x03\x12\x40\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x0d\x00\x00\x00\x00\x00\x00\x48\x02\x5a\x02\x00\x00\x00\x00\x8b\x40\x8b\x40\x00\x00\x00\x00\x8b\x40\x34\x00\x4d\x34\x51\x32\xd0\x32\xca\x56\xa6\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x31\x00\x00\x00\x00\x27\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\x13\x02\x52\x05\x06\x02\x33\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x02\x91\x07\x00\x00\xaa\x28\x72\x2e\x00\x00\x8f\x02\x00\x00\x00\x00\x00\x00\xbc\x02\x8a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x02\x00\x00\x00\x00\x00\x00\xaa\x28\xd9\x04\x9e\x24\xf6\x04\x4d\x05\xc2\x30\x4d\x05\xc2\x30\xe4\x02\xaf\x01\xe7\x02\x06\x2f\x9a\x2f\xc2\x30\xc2\x30\x92\x20\x1a\x1d\xae\x1d\xcc\x31\xa2\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x28\xde\x2d\x3e\x39\x58\x05\xaa\x28\xcc\x31\x68\x56\xf3\x02\x00\x00\xfc\x02\xd0\x04\x60\x03\xba\x03\x00\x00\x00\x00\x00\x00\x9d\x05\xd1\x03\xcf\x03\x53\x00\xcf\x03\x2e\x57\xea\x57\xd1\x03\x42\x1e\x00\x00\xc1\x03\xc1\x03\xc1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x09\x00\x00\x00\x00\x00\x00\x00\x00\x12\x40\x3b\x04\x05\x04\x1f\x04\x7b\x05\x00\x00\xc6\x34\x61\x00\x17\x58\x13\x04\x44\x58\x44\x58\xbd\x57\x00\x00\x00\x00\x00\x00\x00\x00\x23\x04\x00\x00\x23\x04\x73\x04\x30\x04\x8d\x04\x3c\x04\xc4\x04\x00\x00\x00\x00\x00\x00\x7e\x04\x6d\x04\x58\x00\xc8\x00\xc8\x00\xc7\x04\xa2\x04\xc2\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x30\x8b\x04\x4a\x03\x49\x00\x00\x00\x1e\x01\xa8\x04\x77\x01\x00\x00\x1e\x01\xc5\x01\x00\x00\xb7\x04\x71\x03\x25\x59\xd7\x04\x23\x01\x26\x02\x00\x00\x23\x06\x23\x06\x9e\x00\xdf\x04\xe3\x04\xaf\x00\x32\x3c\x12\x40\x02\x03\x3e\x39\xf3\x04\x0f\x05\x12\x05\x1d\x05\x00\x00\x34\x05\x00\x00\x00\x00\x00\x00\x12\x40\x3e\x39\x12\x40\x1a\x05\x3d\x05\x00\x00\xe1\x01\x00\x00\xaa\x28\x00\x00\x00\x00\x45\x35\x07\x55\x12\x40\x4a\x05\x24\x05\x53\x05\x91\x07\x24\x00\x42\x05\x00\x00\xde\x2d\x00\x00\x00\x00\x00\x00\x54\x05\x60\x05\x70\x05\x73\x05\x6a\x1f\x26\x21\x00\x00\x9a\x2f\x00\x00\x00\x00\x07\x55\x83\x05\x86\x05\xc6\x05\x00\x00\xab\x05\x00\x00\xad\x05\x00\x00\x5b\x57\x28\x00\x2e\x57\x00\x00\x64\x01\x2e\x57\x3e\x39\x2e\x57\x00\x00\x1b\x06\xd6\x1e\xd6\x1e\x7b\x59\xc4\x35\xcc\x03\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x05\x00\x04\x66\x04\x00\x00\x00\x00\xaf\x05\xb7\x05\x00\x00\x00\x00\xd5\x05\xfe\x03\xde\x05\x00\x00\x00\x00\x07\x0a\x00\x00\x8c\x01\xd7\x05\x00\x00\x00\x00\xfe\x1f\x00\x00\x0b\x06\x5e\x00\x2a\x06\x0d\x06\x00\x00\x00\x00\x00\x00\x2e\x30\x00\x00\xc2\x30\xc8\x05\x16\x06\x58\x06\x5f\x06\x6a\x06\x00\x00\x00\x00\xc6\x25\xc6\x25\x48\x06\x00\x00\xb0\x06\x53\x06\x56\x00\x00\x00\x00\x00\x3e\x29\x76\x06\x00\x00\xb8\x06\xc2\x30\xd2\x29\xf7\x56\x00\x00\x8b\x40\x00\x00\x3e\x39\xd2\x29\xd2\x29\xd2\x29\xd2\x29\x64\x06\x6d\x06\x75\x04\x78\x06\x81\x06\x71\x02\x86\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x39\x4f\x33\x95\x56\x6f\x06\x82\x06\x3b\x00\x88\x06\x8b\x06\x7b\x04\x00\x00\xdf\x02\x8e\x06\x22\x03\x8f\x06\x00\x00\xb4\x01\x00\x00\x96\x06\x00\x00\x27\x01\x00\x00\x7b\x59\x00\x00\x06\x56\x00\x00\x00\x00\x00\x00\x00\x00\x23\x02\x5a\x0d\x00\x00\xf9\x31\x12\x40\x00\x00\x3e\x39\x3e\x39\x3e\x39\x39\x02\x00\x00\x67\x41\x6b\x00\x00\x00\x8d\x06\x00\x00\x7d\x04\x7d\x04\x5f\x03\x00\x00\x00\x00\x5f\x03\x00\x00\x00\x00\xef\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x06\xe5\x06\xa8\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x06\x00\x00\x3e\x39\x00\x00\x00\x00\x2e\x01\x00\x00\xaf\x02\x93\x06\x00\x00\x00\x00\x3e\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x39\x00\x00\x00\x00\x00\x00\x3e\x39\x3e\x39\x00\x00\x00\x00\x94\x06\x98\x06\x9c\x06\x9f\x06\xa1\x06\xa2\x06\xa7\x06\xa9\x06\xaa\x06\xab\x06\xad\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\xae\x06\x00\x00\xb1\x06\xca\x06\x00\x00\x00\x00\x00\x00\xc8\x05\x45\x00\xc4\x06\xb7\x06\x00\x00\x00\x00\x00\x00\x05\x07\x00\x00\xd2\x29\xd2\x29\x6f\x00\x00\x00\x49\x02\x00\x00\x00\x00\x00\x00\xd0\x06\x00\x00\x32\x25\xa2\x19\xc2\x30\xd2\x06\x76\x23\x00\x00\xd2\x29\x5a\x26\x76\x23\x00\x00\xbe\x06\x00\x00\x00\x00\x00\x00\xba\x21\xcc\x06\x00\x00\x47\x31\x00\x00\x00\x00\x00\x00\x00\x00\x36\x1a\x58\x00\xc2\x06\x00\x00\x00\x00\x00\x00\xc5\x06\x00\x00\xc1\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x58\x00\x00\x00\x00\xda\x06\x00\x00\x3c\x02\xe4\x06\x12\x40\x5a\x0d\x43\x01\x77\x00\x00\x00\x00\x00\x67\x0b\x00\x00\x4e\x22\xe2\x22\x86\x00\x00\x00\xe7\x06\x84\x02\xe1\x02\xe9\x06\x00\x00\xec\x06\xf5\x06\xcf\x06\x00\x00\x00\x00\xe0\x06\xf9\x06\x00\x00\xfe\x06\xe6\x06\xe8\x06\x71\x58\x71\x58\x00\x00\x04\x07\x66\x03\xd1\x03\xed\x06\xee\x06\x06\x07\x00\x00\xf6\x06\x7a\x0c\x00\x00\x00\x00\xd2\x29\x76\x23\x2a\x00\xb1\x3c\x7f\x01\x00\x00\x01\x07\xf0\x00\x0d\x07\x5a\x0d\x00\x00\x00\x00\xd2\x29\x00\x00\x00\x00\x59\x00\x00\x00\xd2\x29\x66\x2a\x12\x40\x4a\x07\x00\x00\x18\x07\x07\x07\x00\x00\x7b\x05\x00\x00\x00\x00\x00\x00\x00\x00\x54\x07\x54\x00\x82\x04\xe8\x02\x00\x00\x24\x07\x5a\x0d\xc4\x35\xc4\x35\x02\x03\xac\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x41\x74\x31\x08\x07\xc4\x35\x00\x00\x74\x31\x7b\x59\xfa\x2a\xfa\x2a\x5d\x07\x00\x00\x0d\x02\x00\x00\xfd\x06\x00\x00\x02\x07\x00\x00\x00\x00\x9e\x58\x9e\x58\x00\x00\x00\x00\x9e\x58\xc2\x30\x32\x07\x34\x07\x00\x00\x6a\x07\x00\x00\x22\x05\x22\x05\x00\x00\x00\x00\x00\x00\x76\x07\x00\x00\x16\x07\x00\x00\x36\x1a\x1e\x07\x80\x01\x80\x01\x1e\x07\x0a\x07\x00\x00\x00\x00\x00\x00\x3c\x07\x00\x00\x00\x00\x00\x00\x55\x02\x00\x00\x00\x00\x76\x01\x23\x07\xde\x2d\xa8\x59\x71\x07\x00\x00\x29\x07\x25\x07\x00\x00\x00\x00\x1d\x07\x00\x00\x3a\x41\x00\x00\x43\x07\x44\x07\x46\x07\x47\x07\xd5\x59\x00\x00\x00\x00\x00\x00\x49\x07\x00\x00\x3b\x07\x3e\x39\x4b\x07\x3e\x39\x5a\x0d\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x05\x3e\x39\x00\x00\x00\x00\x3e\x39\x2d\x07\x00\x00\x2a\x0e\x00\x00\xcf\x05\x00\x00\x4f\x07\x86\x07\x00\x00\x00\x00\xda\x05\x00\x00\x52\x03\x12\x40\x4c\x07\x43\x36\x43\x36\x88\x07\x9f\x07\x58\x07\x3e\x39\x7f\x01\x52\x07\x00\x00\x2f\x5a\x00\x00\x63\x07\x00\x00\x00\x00\x5f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x39\x00\x00\x4e\x07\x3e\x39\x00\x00\x00\x00\x00\x00\x36\x07\x00\x00\xd6\x1e\xfa\x2a\x00\x00\x00\x00\xc2\x36\xd5\x59\x52\x03\x5e\x07\x12\x40\xc2\x36\xc2\x36\xcc\x03\x00\x00\x00\x00\x55\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x8e\x2b\x00\x00\x00\x00\x22\x2c\x00\x00\x58\x00\x56\x07\x00\x00\x89\x03\x00\x00\xee\x26\x57\x07\x00\x00\x39\x07\x00\x00\x82\x27\x00\x00\x00\x00\x00\x00\x22\x2c\xb6\x2c\x4a\x2d\x00\x00\x00\x00\x76\x23\xf7\x56\x00\x00\x00\x00\x00\x00\x3e\x39\x00\x00\x00\x00\x66\x07\x00\x00\x59\x07\x61\x07\x3e\x07\x3e\x39\x00\x00\x3e\x39\xf8\x58\xf7\x05\x00\x00\x67\x07\x67\x07\xb6\x07\xc7\x03\xb7\x07\x00\x00\x2c\x00\x2c\x00\x00\x00\x62\x07\x53\x07\x00\x00\x4d\x07\x00\x00\x00\x00\x69\x07\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x07\x00\x00\x7d\x07\x00\x00\x00\x00\x00\x00\xc2\x07\x8a\x07\x4a\x2d\x4a\x2d\x00\x00\x00\x00\xb0\x07\xca\x03\x16\x28\x16\x28\x4a\x2d\x73\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x36\xc2\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x07\x75\x07\x99\x07\x00\x00\x9a\x07\x00\x00\x87\x07\x12\x40\xce\x07\xea\x07\x00\x00\x70\x07\x00\x00\xeb\x07\x00\x00\x50\x03\xeb\x07\x15\x06\xc2\x36\x86\x02\x41\x37\x00\x00\x00\x00\x4a\x2d\x00\x00\xca\x1a\xca\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x1b\x5e\x1b\x00\x00\x00\x00\x00\x00\xdd\x07\xf9\x31\x00\x00\x12\x40\x3e\x39\xab\x07\xc0\x37\x00\x00\x00\x00\xd5\x59\x00\x00\x00\x00\x41\x06\x9b\x07\x02\x5a\x00\x00\x74\x31\xb8\x0b\x00\x00\x00\x00\x95\x07\x00\x00\x80\x07\x00\x00\x7d\x04\x00\x00\xe4\x07\xb4\x07\xb8\x07\xe8\x07\x9d\x07\x00\x00\x4a\x06\x00\x00\x00\x00\x4a\x06\xec\x07\x00\x00\x00\x00\x4a\x2d\xb9\x07\x00\x00\xf1\x07\xd6\x1e\xd6\x1e\x00\x00\x00\x00\xc0\x37\x00\x00\xbd\x07\x00\x00\xb2\x07\x00\x00\x4d\x06\x00\x00\xfc\x07\x00\x00\x62\x01\x00\x00\x00\x00\xfc\x07\x46\x03\x00\x00\xf9\x31\x00\x00\x00\x00\x90\x01\x00\x00\xf0\x07\xde\x2d\x40\x38\x5a\x03\x00\x00\x00\x00\x00\x00\x87\x03\x87\x03\x00\x00\x15\x03\xdb\x07\x8e\x07\x00\x00\x00\x00\x00\x00\x00\x00\xce\x33\x00\x00\x1c\x00\x00\x00\xfd\x07\x00\x00\x0f\x08\x00\x00\x12\x40\x00\x00\x00\x00\x3e\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x2d\x4a\x2d\x4a\x2d\x00\x00\x00\x00\x00\x00\x9c\x07\x13\x08\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x01\x00\x00\x08\x02\x88\x41\xd5\x03\x51\x06\xb5\x07\x00\x00\x34\x55\xc7\x03\x00\x00\x00\x00\x00\x00\x51\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x03\xba\x07\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x04\x7f\x03\xd4\x04\x9d\x04\xc7\x03\x00\x00\x00\x00\x00\x00\x46\x00\xbb\x07\xbe\x07\xb5\x41\xe5\x07\x7d\x04\x00\x00\x4a\x2d\xd3\x07\x00\x00\x00\x00\xfa\x07\x00\x00\xd4\x07\x00\x00\x00\x00\x2a\x3d\x2f\x5a\xd7\x07\xc3\x07\xd0\x07\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\xcd\x07\x00\x00\xf6\x07\xd8\x07\xed\x07\x00\x00\xf2\x1b\x00\x00\xee\x03\xa9\x3d\x12\x40\x73\x0c\x12\x40\x00\x00\x00\x00\x00\x00\x86\x1c\xa9\x3d\x00\x00\x00\x00\x01\x08\x00\x00\xbd\x39\x3c\x3a\xf9\x31\xbb\x3a\x00\x00\x24\x02\x02\x04\x02\x5a\xbb\x3a\x00\x00\x4e\x08\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\xef\x07\x66\x00\x7d\x04\xdf\x07\xf4\x07\x00\x00\x00\x00\x00\x00\xf9\x31\x00\x00\x28\x02\x00\x00\x58\x00\x18\x04\xf3\x07\x28\x3e\x00\x00\x00\x00\x0a\x08\xbf\x38\x31\x05\x00\x00\x00\x00\xbb\x3a\x3a\x3b\x00\x00\x00\x00\xd1\x03\xbf\x38\x87\x03\x00\x00\x00\x00\xbf\x38\xd5\x07\xfe\x07\x03\x08\x00\x00\xb3\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x12\x40\x4a\x2d\xe1\x07\x00\x00\x50\x00\x7d\x04\x00\x00\x7d\x04\x00\x00\x7d\x04\x00\x00\x00\x00\xfb\x07\xff\x07\x00\x08\x00\x00\xa8\x02\x00\x00\x00\x00\x00\x00\xcf\x55\xee\x07\x00\x00\x00\x00\xc7\x03\x02\x08\xf7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x03\x00\x00\x62\x08\x09\x03\x00\x00\x2f\x00\x50\x00\x06\x08\x1b\x08\x00\x00\x00\x00\x00\x00\xa1\x3e\x00\x00\xf2\x07\x00\x00\x00\x00\x00\x00\x00\x00\x17\x08\x1c\x08\x51\x32\x00\x00\x00\x00\x2f\x5a\x00\x00\x00\x00\x7f\x01\x00\x00\x00\x00\x20\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x08\xc7\x03\x00\x00\x00\x00\x09\x08\xc7\x03\x00\x00\x57\x08\x6d\x08\x2a\x08\xf9\x31\x00\x00\x99\x3f\x00\x00\x00\x00\x63\x08\x16\x08\x06\x10\x7d\x04\x00\x00\x7d\x04\x7d\x04\x00\x00\x7d\x04\xcf\x55\x00\x00\x00\x00\x6b\x55\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x08\x37\x08\x00\x00\x7d\x04\x6c\x08\x60\x06\x00\x00\x00\x00\x7f\x08\x1f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x60\x06\x15\x08\x7d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#  happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\x05\x00\xfe\xff\x1f\x08\xbd\x48\x49\x01\x73\x3b\x5d\x4c\xd0\xff\x03\x49\x01\x00\xea\x12\x8b\x00\x07\x00\x57\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\x3a\x03\x00\x00\x00\x00\x00\x00\x06\x02\x00\x00\x00\x00\x00\x00\x87\x02\x00\x00\x00\x00\xce\x04\xee\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\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\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\xff\x48\x01\x00\x00\x00\x00\xc8\x03\x0d\x01\x07\x13\xa7\x0e\x87\x0e\xca\x01\x5c\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\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\xc7\x05\x24\x07\x9a\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x0a\x00\x00\xf0\x3c\x4c\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x3e\x64\x07\xfd\x4a\x7b\x04\x65\x07\x8a\x5b\x69\x07\xc8\x5b\x00\x00\x00\x00\x00\x00\xfd\x5a\x3c\x5b\xd8\x5b\x16\x5c\x7b\x44\xb0\x42\x96\x43\x05\x44\x2e\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x4d\x69\x3f\x24\x13\x87\x07\x75\x4d\x2c\x5d\x5c\x05\x21\x08\x00\x00\x00\x00\x22\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x04\xb9\x02\x8d\x04\xb2\x04\xd3\x04\x74\x03\x52\x03\xc7\x02\x23\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x02\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x02\x00\x00\x00\x00\x3e\x05\x19\x08\x00\x00\xc2\x01\xdd\x07\x89\x00\x4a\x05\xe4\x01\x9a\x00\x68\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x08\x00\x00\x00\x00\x00\x00\x00\x00\x29\x01\x00\x00\x30\x02\x00\x00\xc5\x02\x36\x07\x37\x07\x38\x07\x32\x08\x00\x00\x54\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x5c\x57\x07\xcf\x03\x00\x00\x00\x00\xeb\x07\x00\x00\x00\x00\x00\x00\xec\x07\x00\x00\x00\x00\xb6\x05\x00\x00\xc0\xff\x00\x00\x3c\x00\x10\x03\x00\x00\xee\x07\xef\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\xca\x16\x98\x03\x5a\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x16\x16\x11\x30\x17\xcb\x07\x00\x00\x00\x00\x20\x03\x00\x00\xc9\x41\x00\x00\x00\x00\xb4\x08\x9a\x04\x84\x08\x15\x08\x00\x00\x00\x00\x76\x0c\x8c\xff\x00\x00\x00\x00\xa8\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x44\xc2\x45\x00\x00\x3c\x5b\x00\x00\x00\x00\xe5\x04\x00\x00\xe5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x06\x00\x00\xe1\x03\x00\x00\xfd\x07\x1e\x04\x7c\x0f\x57\x04\x00\x00\x00\x00\x64\x03\xe6\x03\x85\x00\xec\x08\xeb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x01\x45\x07\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x11\x00\x00\x00\x31\x0d\x00\x00\x00\x00\x00\x00\xc7\x05\xbb\x07\x8c\xff\x00\x00\x00\x00\x00\x00\xe8\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x5c\x00\x00\x77\x5a\xc2\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x49\x8f\x49\x00\x00\x00\x00\x00\x00\xbe\x07\x7b\xff\x00\x00\x00\x00\xd5\x49\x77\x05\x00\x00\x00\x00\xe0\x5c\xbb\x4d\x9b\x02\x00\x00\xb4\x05\x00\x00\xf9\x10\x01\x4e\x47\x4e\x8d\x4e\xd3\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x11\x5c\x0e\x14\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\xa3\x01\x00\x00\xaa\x00\x00\x00\xed\x03\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x07\x47\x01\x00\x00\x8c\x02\x47\x17\x00\x00\xa8\x15\xc5\x15\xb7\x13\x00\x00\x00\x00\x16\x00\x4a\x07\x00\x00\xe7\x02\x00\x00\x4f\x07\x51\x07\x62\x08\x00\x00\x00\x00\x6f\x08\x00\x00\x00\x00\x56\x08\x00\x00\x00\x00\x00\x00\x00\x00\x85\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\xe2\x15\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x02\x00\x00\x00\x00\x00\x00\x50\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x11\x00\x00\x00\x00\x00\x00\x00\x12\x1d\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x07\xbd\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x4f\x5f\x4f\x5a\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x4a\x30\x48\xba\x5a\x00\x00\x2f\x46\x00\x00\xa5\x4f\xe3\x47\x9c\x46\x00\x00\x92\xff\x00\x00\x00\x00\x00\x00\x55\x45\x00\x00\x00\x00\xfc\x09\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x01\x5e\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\xa9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x07\x00\x00\x45\x08\x50\x01\x00\x00\x62\x07\x00\x00\x00\x00\x47\x02\x00\x00\x00\x00\x00\x00\x6a\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\x5b\x06\x5a\x05\x00\x00\x00\x00\xbc\x05\xf1\x02\x00\x00\x00\x00\x99\x04\x00\x00\x00\x00\x31\x0d\x00\x00\x00\x00\xc9\x41\x09\x47\x00\x00\xcc\x04\xb0\xff\x00\x00\x00\x00\x5d\x07\x00\x00\x65\x01\x00\x00\x00\x00\xde\x41\x00\x00\x00\x00\x2f\x00\x00\x00\xeb\x4f\x68\x4a\x68\x17\x30\x08\x62\x03\x47\x08\x00\x00\x00\x00\x5c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x36\x08\xc0\x04\xd8\x04\x50\x08\x00\x00\x00\x00\x94\x01\x9f\x0c\xbc\x0c\xb8\x03\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xff\xfc\x01\x85\x07\x52\x09\x00\x00\xd4\xff\x51\x00\xa3\x4c\xe9\x4c\x35\x08\x00\x00\x38\x08\x00\x00\x3b\x08\x00\x00\x31\x08\x00\x00\x00\x00\xd5\x00\x53\x09\x00\x00\x00\x00\xc6\x00\xf0\x5c\x00\x00\x00\x00\x00\x00\x7d\x08\x00\x00\x9c\x08\x9d\x08\x00\x00\x00\x00\x00\x00\xbd\x03\x00\x00\x8b\x08\x00\x00\xdf\x01\x9a\x08\x40\x08\x43\x08\xa4\x08\x92\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\xee\x59\xe5\xff\x63\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x13\x80\x08\xf1\x13\x09\x01\x00\x00\x6a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x08\x0f\x10\x00\x00\x00\x00\x0e\x14\x00\x00\x00\x00\xa8\x02\x00\x00\x67\x08\x00\x00\x00\x00\x5a\x08\x00\x00\x00\x00\x71\x05\x00\x00\x46\x08\x86\x17\x00\x00\x3b\x0b\x58\x0b\x29\x08\xd7\x04\x00\x00\xa1\x14\xbf\xff\x00\x00\x00\x00\x9b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x10\x00\x00\x00\x00\x49\x10\x00\x00\x00\x00\x00\x00\x1e\x05\x00\x00\x74\x07\x31\x50\x00\x00\x00\x00\x8a\x09\x54\x03\x49\x08\x00\x00\x99\x17\xdb\x0c\x6f\x0d\x54\x04\x00\x00\x00\x00\xb5\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\x77\x50\x00\x00\x00\x00\xbd\x50\x00\x00\xd0\x07\x00\x00\x00\x00\xe1\x04\x00\x00\xb5\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x43\x4b\x00\x00\x00\x00\x00\x00\x03\x51\xcf\x4b\x49\x51\x00\x00\x00\x00\x76\x47\x9d\x01\x00\x00\x00\x00\x00\x00\x3a\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x03\x75\x16\x00\x00\xbe\x14\x22\x00\xd7\x08\x00\x00\xc6\x08\xc7\x08\x00\x00\x15\x00\x00\x00\x00\x00\xfb\xff\xfd\xff\x00\x00\x00\x00\x84\x03\x00\x00\xa2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x08\x04\x08\x8f\x51\x17\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x77\x48\x89\x4b\xd5\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x0d\xab\x0d\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\x18\x4a\x08\xeb\x04\x00\x00\xa5\xff\x00\x00\x37\x08\x00\x00\x0c\x00\x1f\x05\x00\x00\x3f\x0e\x00\x00\xaa\x0b\x00\x00\x00\x00\x1b\x52\x00\x00\x68\x04\xea\x04\x00\x00\x4b\x08\x40\x05\x00\x00\x00\x00\x00\x00\x60\x02\xe2\x02\x00\x00\x00\x00\x00\x00\xab\x08\x12\x00\x00\x00\x24\x18\xdb\x14\x00\x00\xa7\x09\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\x00\x00\x11\x02\x31\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x08\x00\x00\x00\x00\xe7\x08\xcb\x08\x00\x00\x00\x00\x61\x52\x00\x00\x00\x00\x00\x00\x70\x06\xf2\x06\x00\x00\x00\x00\xf9\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x08\x00\x00\xb0\x08\x00\x00\xd5\x07\x00\x00\x00\x00\xb7\x08\x00\x00\x00\x00\xa8\x02\x00\x00\x00\x00\xde\x07\x00\x00\xbb\x08\x34\x5a\xbb\x06\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x02\xdb\x02\x00\x00\x38\x01\xcc\x08\xe0\x07\x00\x00\x00\x00\x00\x00\x00\x00\xec\x0b\x00\x00\x2b\x02\x00\x00\x69\x08\x00\x00\x6d\x05\x00\x00\xa5\x16\x00\x00\x00\x00\x66\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x52\xed\x52\x33\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x07\x00\x00\x00\x00\x26\x00\x00\x00\xf9\x08\x00\x00\x00\x00\x55\x00\xe3\xff\x00\x00\x00\x00\x00\x00\xfc\x08\x00\x00\xa4\x02\x17\x03\x00\x00\x27\x00\xf3\x08\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x07\xd5\x03\x6e\x02\xdc\x04\x2b\x00\x00\x00\x00\x00\x00\x00\x03\x00\x0f\x09\x00\x00\x29\x00\xee\x08\xf4\x07\x00\x00\x79\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x0a\xe6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x05\x00\x00\xce\x08\xb1\x07\x3b\x18\x31\x0d\x55\x18\x00\x00\x00\x00\x00\x00\x6c\x05\xc8\x07\x00\x00\x00\x00\xcd\x08\x00\x00\xaf\x03\x35\x05\x3e\x00\xf8\x14\x00\x00\xf8\x07\x00\x00\x4c\x00\x92\x16\x00\x00\xf5\x08\x00\x00\x67\x02\x74\x02\x00\x00\xfb\x07\x00\x00\x15\x06\xfe\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xff\x00\x00\x00\x08\x00\x00\x06\x08\x00\x00\x00\x00\x97\x08\x00\x00\x00\x00\xde\x08\x44\x0a\xd5\x08\x00\x00\x00\x00\x8b\x15\xcd\x12\x00\x00\x00\x00\xf4\x01\x62\x0a\x0c\x03\x00\x00\x00\x00\x0b\x0c\x8b\x03\x00\x00\x00\x00\x00\x00\x03\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x18\xbf\x53\x00\x00\x00\x00\x1e\x09\x07\x08\x00\x00\xff\xff\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\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\x20\x09\x17\x09\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x0a\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x0f\x00\x00\x00\x00\x5e\x01\x00\x00\x00\x00\xc9\xff\x00\x00\x00\x00\xe9\x07\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\x1e\x00\x00\x00\x91\x08\x95\x05\x00\x00\x1b\x00\x00\x00\x03\x0b\x00\x00\x00\x00\x00\x00\x19\x09\x1f\x00\x0e\x08\x00\x00\x02\x00\x0f\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\x12\x08\x00\x00\x28\x09\x00\x00\x00\x00\xc8\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x09\x00\x00\x1a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#+happyGotoOffsets = HappyA# "\x05\x00\xfe\xff\x5a\x08\x57\x47\x49\x01\xc9\x4b\xf7\x4a\xd0\xff\x9d\x47\x01\x00\xea\x12\xf6\x01\x07\x00\x68\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\x6a\x05\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x6f\x02\x00\x00\x00\x00\x81\x05\x88\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\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\xf3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\xff\x48\x01\x00\x00\x00\x00\xc8\x03\x0d\x01\x07\x13\xa7\x0e\x87\x0e\x93\x01\x53\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x05\x5c\x07\xe1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x0a\x00\x00\x0f\x4c\x57\x5b\x00\x00\x00\x00\x00\x00\x00\x00\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\x4c\xa0\x07\x97\x49\x71\x05\xa1\x07\x95\x5b\xa2\x07\xa5\x5b\x00\x00\x00\x00\x00\x00\x09\x5b\x19\x5b\xe3\x5b\x21\x5c\x15\x43\xbc\x41\xa2\x42\x47\x5d\x2e\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x4c\xa7\x59\x24\x13\xbf\x07\xe1\x4c\x83\x5d\xf1\x04\x5e\x08\x00\x00\x00\x00\x22\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x05\x2c\x02\x2a\x05\x39\x05\x44\x05\x7c\x03\xdc\x05\x7a\x03\x2f\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x02\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x02\x00\x00\x00\x00\x8c\x06\x54\x08\x00\x00\xc2\x01\x18\x08\x89\x00\xa3\x05\xe4\x01\x9a\x00\x6c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x00\x00\x30\x02\x00\x00\x85\x02\x6e\x07\x77\x07\x7e\x07\x6f\x08\x00\x00\x31\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x5c\x8f\x07\x3c\x03\x00\x00\x00\x00\x21\x08\x00\x00\x00\x00\x00\x00\x25\x08\x00\x00\x00\x00\x06\x04\x00\x00\xc0\xff\x00\x00\x71\xff\xd0\x03\x00\x00\x22\x08\x23\x08\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x01\xca\x16\x9a\x03\x5a\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x16\x16\x11\x30\x17\x0b\x08\x00\x00\x00\x00\x85\x04\x00\x00\x3e\x41\x00\x00\x00\x00\xb4\x08\xe1\x03\x84\x08\x52\x08\x00\x00\x00\x00\x7c\x0c\x8c\xff\x00\x00\x00\x00\xb7\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x43\x5c\x44\x00\x00\x19\x5b\x00\x00\x00\x00\xe6\x04\x00\x00\x29\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x06\x00\x00\xd2\x03\x00\x00\x3b\x08\x78\x04\x7c\x0f\xfa\x04\x00\x00\x00\x00\x64\x03\xe6\x03\x85\x00\xec\x08\xeb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x81\x07\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x11\x00\x00\x00\x4c\x0d\x00\x00\x00\x00\x00\x00\x45\x05\xe2\x07\x8c\xff\x00\x00\x00\x00\x00\x00\x82\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x5c\x00\x00\x95\x5a\xd6\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x47\x29\x48\x00\x00\x00\x00\x00\x00\x04\x08\xb8\xff\x00\x00\x00\x00\x6f\x48\xe4\x05\x00\x00\x00\x00\xbd\x5c\x27\x4d\x9b\x02\x00\x00\xb4\x05\x00\x00\xf9\x10\x6d\x4d\xb3\x4d\xf9\x4d\x3f\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x11\x5c\x0e\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\xb7\x02\x00\x00\xaa\x00\x00\x00\x5c\x05\x00\x00\x00\x00\x00\x00\x00\x00\x27\x08\x47\x01\x00\x00\x41\x02\x47\x17\x00\x00\xa8\x15\xc5\x15\xb7\x13\x00\x00\x00\x00\x16\x00\x8b\x07\x00\x00\x16\x03\x00\x00\x85\x07\x89\x07\x9e\x08\x00\x00\x00\x00\xa3\x08\x00\x00\x00\x00\x8a\x08\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x15\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x04\x00\x00\x00\x00\x00\x00\x50\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x11\x00\x00\x00\x00\x00\x00\x00\x12\x1d\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x07\xd9\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x4e\xcb\x4e\x97\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x48\xca\x46\xa5\x5a\x00\x00\xc9\x44\x00\x00\x11\x4f\x7d\x46\x36\x45\x00\x00\x92\xff\x00\x00\x00\x00\x00\x00\xef\x43\x00\x00\x00\x00\xfc\x09\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x01\xa3\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\xcd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x94\x07\x00\x00\x45\x08\x50\x01\x00\x00\xa4\x07\x00\x00\x00\x00\x47\x02\x00\x00\x00\x00\x00\x00\xa7\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\xcd\x02\x5a\x05\x00\x00\x00\x00\xbc\x05\x8e\x03\x00\x00\x00\x00\x66\x05\x00\x00\x00\x00\x4c\x0d\x00\x00\x00\x00\x3e\x41\xa3\x45\x00\x00\xcc\x04\xb0\xff\x00\x00\x00\x00\x96\x07\x00\x00\x65\x01\x00\x00\x00\x00\x4e\x41\x00\x00\x00\x00\xf8\xff\x00\x00\x57\x4f\x02\x49\x68\x17\x60\x08\x62\x03\x72\x08\x00\x00\x00\x00\x8b\x08\x00\x00\x00\x00\x00\x00\x00\x00\x74\x08\xef\x04\xd2\x05\x8c\x08\x00\x00\x00\x00\x94\x01\x9f\x0c\xbc\x0c\xb8\x03\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xff\x86\x03\xbc\x07\x52\x09\x00\x00\xd4\xff\x51\x00\x3d\x4b\x83\x4b\x70\x08\x00\x00\x73\x08\x00\x00\x76\x08\x00\x00\x6b\x08\x00\x00\x00\x00\xd5\x00\x5b\x06\x00\x00\x00\x00\xc6\x00\xfb\x5c\x00\x00\x00\x00\x00\x00\xb6\x08\x00\x00\xd5\x08\xd6\x08\x00\x00\x00\x00\x00\x00\xc2\x03\x00\x00\xc1\x08\x00\x00\xdf\x01\xd0\x08\x75\x08\x78\x08\xd1\x08\xc5\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\x21\x5a\xe5\xff\x99\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x13\xb7\x08\xf1\x13\x09\x01\x00\x00\x9f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x94\x08\x0f\x10\x00\x00\x00\x00\x0e\x14\x00\x00\x00\x00\x7c\x02\x00\x00\x9a\x08\x00\x00\x00\x00\x90\x08\x00\x00\x00\x00\xb3\x05\x00\x00\x77\x08\x86\x17\x00\x00\x3b\x0b\x58\x0b\x61\x08\xc1\x04\x00\x00\xa1\x14\xbf\xff\x00\x00\x00\x00\x9b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x10\x00\x00\x00\x00\x49\x10\x00\x00\x00\x00\x00\x00\xf1\x05\x00\x00\x74\x07\x9d\x4f\x00\x00\x00\x00\x8a\x09\x04\x03\x7c\x08\x00\x00\x99\x17\xdb\x0c\x6f\x0d\xc7\x01\x00\x00\x00\x00\xdd\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\xe3\x4f\x00\x00\x00\x00\x29\x50\x00\x00\xde\x07\x00\x00\x00\x00\x10\x05\x00\x00\x4f\x49\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x49\x00\x00\x00\x00\x00\x00\x6f\x50\x69\x4a\xb5\x50\x00\x00\x00\x00\x10\x46\x33\x02\x00\x00\x00\x00\x00\x00\x3a\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x03\x75\x16\x00\x00\xbe\x14\x22\x00\xfc\x08\x00\x00\xed\x08\xf0\x08\x00\x00\x15\x00\x00\x00\x00\x00\xfb\xff\xfd\xff\x00\x00\x00\x00\xe0\x03\x00\x00\xa2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x08\x2c\x08\xfb\x50\xb1\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x11\x47\x23\x4a\x41\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x0d\xab\x0d\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\x18\x6e\x08\x1e\x05\x00\x00\xa5\xff\x00\x00\x64\x08\x00\x00\x0c\x00\x30\x05\x00\x00\x3f\x0e\x00\x00\xaa\x0b\x00\x00\x00\x00\x87\x51\x00\x00\x68\x04\xea\x04\x00\x00\x7a\x08\x46\x06\x00\x00\x00\x00\x00\x00\x60\x02\xe2\x02\x00\x00\x00\x00\x00\x00\xcd\x08\x12\x00\x00\x00\x24\x18\xdb\x14\x00\x00\xa7\x09\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\x00\x00\x95\x03\x4c\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x09\x00\x00\x00\x00\x03\x09\xee\x08\x00\x00\x00\x00\xcd\x51\x00\x00\x00\x00\x00\x00\x70\x06\xf2\x06\x00\x00\x00\x00\xf9\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x08\x00\x00\xd8\x08\x00\x00\xf8\x07\x00\x00\x00\x00\xda\x08\x00\x00\x00\x00\x7c\x02\x00\x00\x00\x00\xf9\x07\x00\x00\xdc\x08\x31\x5a\xbb\x06\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x02\xdb\x02\x00\x00\x38\x01\xdb\x08\x05\x08\x00\x00\x00\x00\x00\x00\x00\x00\xec\x0b\x00\x00\x8c\x03\x00\x00\x7e\x08\x00\x00\xb2\x05\x00\x00\xa5\x16\x00\x00\x00\x00\x66\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x52\x59\x52\x9f\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x08\x00\x00\x00\x00\x26\x00\x00\x00\x11\x09\x00\x00\x00\x00\x55\x00\xe3\xff\x00\x00\x00\x00\x00\x00\x16\x09\x00\x00\xd6\x02\xf7\x02\x00\x00\x27\x00\x0d\x09\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x08\xfd\x03\xd0\x00\x76\x05\x2b\x00\x00\x00\x00\x00\x00\x00\x03\x00\x2a\x09\x00\x00\x29\x00\x05\x09\x11\x08\x00\x00\xe5\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x0a\xe6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x05\x00\x00\xe1\x08\xb1\x07\x3b\x18\x4c\x0d\x55\x18\x00\x00\x00\x00\x00\x00\x6c\x05\xc8\x07\x00\x00\x00\x00\xe0\x08\x00\x00\xaf\x03\x35\x05\x3e\x00\xf8\x14\x00\x00\x14\x08\x00\x00\x4c\x00\x92\x16\x00\x00\x0b\x09\x00\x00\x3e\x02\xa4\x02\x00\x00\x1d\x08\x00\x00\xb6\x06\x1a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xff\x00\x00\x2d\x08\x00\x00\x2e\x08\x00\x00\x00\x00\x97\x08\x00\x00\x00\x00\xf5\x08\x44\x0a\xfe\x08\x00\x00\x00\x00\x8b\x15\xcd\x12\x00\x00\x00\x00\xf4\x01\x62\x0a\x0c\x03\x00\x00\x00\x00\x0b\x0c\xf5\x03\x00\x00\x00\x00\x00\x00\x03\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x18\x2b\x53\x00\x00\x00\x00\x43\x09\x2f\x08\x00\x00\xff\xff\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x01\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\x46\x09\x3e\x09\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x0a\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x0f\x00\x00\x00\x00\x5e\x01\x00\x00\x00\x00\xc9\xff\x00\x00\x00\x00\xe9\x07\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\x1e\x00\x00\x00\xbb\x08\xca\x05\x00\x00\x1b\x00\x00\x00\x03\x0b\x00\x00\x00\x00\x00\x00\x45\x09\x1f\x00\x35\x08\x00\x00\x02\x00\x38\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\x39\x08\x00\x00\x51\x09\x00\x00\x00\x00\xd3\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x09\x00\x00\x3e\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#  happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# happyAdjustOffset off = off@@ -2366,10 +2367,10 @@ happyDefActions = HappyA# "\xc0\xff\xc1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfd\x00\x00\x00\x00\xbf\xff\xc0\xff\x00\x00\xf2\xff\x12\xfd\x0f\xfd\x0c\xfd\xfc\xfc\xfa\xfc\xfb\xfc\x08\xfd\xf9\xfc\xf8\xfc\xf7\xfc\x0a\xfd\x09\xfd\x0b\xfd\x07\xfd\x06\xfd\xf6\xfc\xf5\xfc\xf4\xfc\xf3\xfc\xf2\xfc\xf1\xfc\xf0\xfc\xef\xfc\xee\xfc\xed\xfc\xeb\xfc\xec\xfc\x00\x00\x0d\xfd\x0e\xfd\x00\x00\x8b\xff\x00\x00\xb1\xff\xc2\xff\x8b\xff\xcb\xfc\x00\x00\x00\x00\x00\x00\x7a\xfe\x00\x00\x9e\xfe\x00\x00\x97\xfe\x90\xfe\x83\xfe\x82\xfe\x80\xfe\x6c\xfe\x6b\xfe\x00\x00\x79\xfe\x45\xfd\x7e\xfe\x40\xfd\x37\xfd\x3a\xfd\x31\xfd\x78\xfe\x7d\xfe\x1b\xfd\x18\xfd\x63\xfe\x58\xfe\x16\xfd\x15\xfd\x17\xfd\x00\x00\x00\x00\x2e\xfd\x2d\xfd\x00\x00\x00\x00\x77\xfe\x2c\xfd\x00\x00\xc7\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\xfd\x34\xfd\x2f\xfd\x30\xfd\x38\xfd\x32\xfd\x33\xfd\x6c\xfd\x64\xfe\x65\xfe\x00\x00\x0d\xfe\x0c\xfe\x00\x00\xf1\xff\x5b\xfd\x4e\xfd\x5a\xfd\xef\xff\xf0\xff\x1f\xfd\x04\xfd\x05\xfd\x00\xfd\xfd\xfc\x59\xfd\xe8\xfc\x4a\xfd\xe5\xfc\xe2\xfc\xff\xfc\xe9\xfc\xea\xfc\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xfc\xfe\xfc\xe3\xfc\xe7\xfc\x01\xfd\xe4\xfc\xcc\xfd\x79\xfd\x06\xfe\x04\xfe\x00\x00\xff\xfd\xf5\xfd\xe8\xfd\xe6\xfd\xd8\xfd\xd7\xfd\x00\x00\x00\x00\x7f\xfd\x7c\xfd\xe3\xfd\xe2\xfd\xe4\xfd\xe5\xfd\xe1\xfd\x05\xfe\xd9\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\x00\x00\x00\x00\x00\x00\x00\x00\x6b\xfd\xe1\xfc\xe0\xfc\xe0\xfd\xdf\xfd\xdd\xfc\xdc\xfc\xdf\xfc\xde\xfc\xdb\xfc\xda\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\xfd\x78\xff\x1a\xfe\x00\x00\x00\x00\x00\x00\x0f\xfd\x76\xff\x75\xff\x74\xff\x00\x00\x00\x00\x11\xfe\x11\xfe\x11\xfe\x00\x00\x69\xfd\x00\x00\x00\x00\x8a\xfd\x00\x00\x00\x00\x00\x00\x6e\xff\x6d\xff\x6c\xff\x6b\xff\x14\xff\x6a\xff\x69\xff\x26\xfe\x63\xff\x25\xfe\x2d\xfe\x62\xff\x28\xfe\x61\xff\x2c\xfe\x2b\xfe\x2a\xfe\x29\xfe\x00\x00\x28\xff\x00\x00\x46\xff\x4f\xff\x27\xff\x00\x00\x00\x00\x00\x00\xdb\xfe\xc3\xfe\xc8\xfe\x00\x00\xcf\xfc\xce\xfc\xcd\xfc\xcc\xfc\x00\x00\x7d\xfd\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\x5e\xfd\x55\xfd\x5f\xfd\x14\xfd\x57\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc9\xfe\x00\x00\x61\xfd\x00\x00\xc4\xfe\x00\x00\x00\x00\xdc\xfe\xd9\xfe\x00\x00\x54\xfd\x00\x00\x00\x00\x00\x00\x67\xff\x00\x00\x00\x00\x00\x00\x00\x00\x90\xfe\x45\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\xff\x00\x00\x48\xff\x4a\xff\x49\xff\x00\x00\x5e\xfe\x00\x00\x55\xfe\x00\x00\x1b\xff\x00\x00\x25\xfd\x00\x00\x24\xfd\x26\xfd\x00\x00\x00\x00\x00\x00\x14\xff\x00\x00\xbf\xfd\x06\xfe\x00\x00\x00\x00\x22\xfd\x00\x00\x21\xfd\x23\xfd\x1d\xfd\x02\xfd\x00\x00\x03\xfd\x4a\xfd\x00\x00\x00\x00\xd0\xfc\xff\xfc\x52\xfd\xd4\xfc\x00\x00\x54\xfd\xaa\xfe\x00\x00\x6a\xfd\x68\xfd\x66\xfd\x65\xfd\x62\xfd\x00\x00\x00\x00\x00\x00\x10\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xe3\xfe\x00\x00\xe6\xfe\xe6\xfe\x00\x00\x00\x00\x00\x00\x77\xff\xd3\xfd\x48\xfd\xd4\xfd\x00\x00\x00\x00\x00\x00\xc7\xfd\xe5\xfd\x00\x00\x00\x00\x6f\xff\x6f\xff\x00\x00\x00\x00\x00\x00\xd5\xfd\xd6\xfd\x00\x00\xc5\xfd\x00\x00\x00\x00\x02\xfd\x03\xfd\x00\x00\x50\xfd\x00\x00\xb3\xfd\x00\x00\xb2\xfd\x4d\xfd\xf2\xfd\xf3\xfd\x00\xfe\x88\xfd\x86\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xfd\x7b\xfd\x80\xfd\x80\xfd\x00\x00\xea\xfd\x78\xfd\xfd\xfd\x00\x00\xed\xfd\x8e\xfd\x00\x00\x00\x00\xeb\xfd\x00\x00\x00\x00\x00\x00\x76\xfd\xf8\xfd\x00\x00\xc6\xfc\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\xfd\x6a\xfe\x5d\xfd\x5c\xfd\x7c\xfe\x7b\xfe\x67\xfe\x28\xfd\x5e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x5d\xfe\x00\x00\x00\x00\x00\x00\x71\xfe\x00\x00\x3a\xfd\x00\x00\x00\x00\x73\xfe\x00\x00\x41\xfd\x00\x00\x3b\xfe\x39\xfe\xc8\xfc\x00\x00\x7f\xfe\x00\x00\x75\xfe\x76\xfe\xa1\xfe\xa2\xfe\x00\x00\x58\xfe\x57\xfe\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xe9\xff\x00\x00\x00\x00\xae\xff\x88\xff\xad\xff\x00\x00\x00\x00\xbc\xff\xd7\xfc\xd6\xfc\xbc\xff\xac\xff\xaa\xff\xab\xff\x8c\xff\xed\xff\xd8\xfc\xd9\xfc\xea\xff\x00\x00\xd9\xff\xdd\xff\xda\xff\xdc\xff\xdb\xff\xde\xff\xec\xff\x4e\xfe\x9d\xfe\x99\xfe\x8f\xfe\x98\xfe\x00\x00\x59\xfe\x00\x00\x9f\xfe\xa0\xfe\x00\x00\xa5\xfe\x00\x00\x00\x00\x74\xfe\x6e\xfe\x00\x00\x42\xfd\x44\xfd\xd5\xfc\x3f\xfd\x6d\xfe\x00\x00\x43\xfd\x6f\xfe\x70\xfe\x00\x00\x00\x00\x1a\xfd\x39\xfd\x00\x00\x00\x00\x00\x00\x2e\xfd\x2d\xfd\x77\xfe\x2c\xfd\x2f\xfd\x30\xfd\x33\xfd\x5d\xfe\x00\x00\x5f\xfe\xee\xff\x51\xfd\x58\xfd\x10\xfd\x4f\xfd\x49\xfd\x1e\xfd\x07\xfe\x08\xfe\x09\xfe\x0a\xfe\x0b\xfe\xa8\xfe\xf7\xfd\x00\x00\x77\xfd\x74\xfd\x71\xfd\x73\xfd\x7a\xfd\xf4\xfd\x00\x00\x00\x00\x00\x00\x9f\xfd\x9d\xfd\x8f\xfd\x8c\xfd\x00\x00\xfe\xfd\x00\x00\x00\x00\x00\x00\x81\xfd\x00\x00\xf9\xfd\xfc\xfd\xfb\xfd\x00\x00\xef\xfd\x00\x00\x00\x00\x86\xfd\x00\x00\x00\x00\xda\xfd\xb1\xfd\x00\x00\x00\x00\x11\xfd\xb5\xfd\xb9\xfd\xdb\xfd\xbb\xfd\xb4\xfd\xba\xfd\xdc\xfd\x00\x00\xd1\xfd\xce\xfd\xcf\xfd\xc0\xfd\xc1\xfd\x00\x00\x00\x00\xcd\xfd\xd0\xfd\x46\xfd\x00\x00\x47\xfd\x1b\xfe\x2a\xfd\x72\xff\x2b\xfd\x4c\xfd\x29\xfd\x00\x00\x1d\xfe\xa7\xfe\x00\x00\x93\xfe\x8e\xfe\x00\x00\x00\x00\x58\xfe\x00\x00\x00\x00\x24\xfe\xe7\xfe\xac\xfe\x23\xfe\xca\xfd\xc9\xfd\x00\x00\x6e\xfd\xe3\xfd\x00\x00\x00\x00\x00\x00\x62\xfe\x00\x00\x00\x00\x00\x00\xd7\xfe\xd6\xfe\x00\x00\x00\x00\x17\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\xfc\xd1\xfc\x11\xfd\xbd\xfd\xdd\xfd\xde\xfd\xbe\xfd\x00\x00\x00\x00\x00\x00\x26\xff\xab\xfe\x00\x00\x8e\xfe\x00\x00\x58\xfe\x03\xfe\x02\xfe\x00\x00\x01\xfe\x27\xfe\xdf\xfe\x1f\xfe\x00\x00\x00\x00\x00\x00\xf4\xfe\x50\xfe\x24\xff\x00\x00\x4b\xff\x4f\xff\x50\xff\x51\xff\x53\xff\x52\xff\xea\xfe\x11\xff\x00\x00\x22\xff\x56\xff\x00\x00\x58\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xb6\xfe\xb5\xfe\xb4\xfe\xb3\xfe\xb2\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x08\xff\x05\xff\x00\x00\x00\x00\x00\x00\xd0\xfe\xd8\xfe\x00\x00\x64\xff\xdd\xfe\xc2\xfe\xbd\xfe\xc1\xfe\x66\xff\xc5\xfe\x00\x00\xc7\xfe\x65\xff\xca\xfe\x00\x00\x00\x00\x00\x00\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\xbc\xfe\xba\xfe\x00\x00\xcb\xfe\x60\xfd\xc6\xfe\x00\x00\xbe\xfe\xde\xfe\x00\x00\x00\x00\x00\x00\xce\xfe\x0a\xff\x0b\xff\x00\x00\x03\xff\x04\xff\xff\xfe\x00\x00\x07\xff\x00\x00\xb8\xfe\x00\x00\xb0\xfe\xaf\xfe\xb1\xfe\x00\x00\xb7\xfe\x59\xff\x5a\xff\x9c\xfe\x5f\xff\x00\x00\x00\x00\x45\xff\x00\x00\x00\x00\x12\xff\x10\xff\x0f\xff\x0c\xff\x0d\xff\x57\xff\x00\x00\x00\x00\x68\xff\x5b\xff\x00\x00\x54\xfe\x52\xfe\x00\x00\x60\xff\x00\x00\x1c\xff\x00\x00\xdf\xfe\x21\xfe\x20\xfe\x00\x00\xc5\xfc\x00\x00\x00\x00\x8d\xfe\x00\x00\x00\x00\x4b\xfe\x37\xfe\x00\x00\x00\x00\x26\xff\x00\x00\x17\xff\x58\xfe\x15\xff\x00\x00\xbc\xfd\xb8\xfd\xd3\xfc\x20\xfd\x1c\xfd\x53\xfd\xa9\xfe\x19\xfe\x67\xfd\x64\xfd\x56\xfd\x63\xfd\x16\xfe\x00\x00\x0f\xfe\x00\x00\x00\x00\x13\xfe\x18\xfe\xe2\xfe\x6f\xfd\xe5\xfe\xe8\xfe\x00\x00\xe1\xfe\xe4\xfe\x00\x00\x00\x00\x00\x00\x8c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xc3\xfd\xc2\xfd\x71\xff\xc4\xfd\xc6\xfd\xcb\xfd\xb7\xfd\xb6\xfd\xbf\xfd\xab\xfd\xad\xfd\xaa\xfd\xa8\xfd\xa5\xfd\xa4\xfd\x00\x00\xaf\xfd\xac\xfd\x00\x00\x87\xfd\x00\x00\x98\xfd\x94\xfd\x00\x00\x99\xfd\x00\x00\x00\x00\x9a\xfd\x00\x00\x85\xfd\x82\xfd\x84\xfd\xe9\xfd\xf0\xfd\x00\x00\x00\x00\x00\x00\x8d\xfd\xec\xfd\x00\x00\x00\x00\xe7\xfd\x68\xfe\x13\xfd\x00\x00\x27\xfd\x5c\xfe\x5b\xfe\x5a\xfe\x00\x00\x00\x00\xc9\xfc\x00\x00\x9a\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\xc9\xfc\xca\xfc\xc7\xfc\x66\xfe\x72\xfe\x00\x00\x75\xfd\x72\xfd\x8b\xfd\x9e\xfd\xfd\xfd\x83\xfd\x00\x00\x9c\xfd\x97\xfd\x93\xfd\xdf\xfe\x90\xfd\x00\x00\x95\xfd\x9b\xfd\xf1\xfd\xa3\xfd\xf1\xfc\x00\x00\x00\x00\xb0\xfd\x70\xff\x8d\xff\x73\xff\x95\xfe\x8b\xfe\x94\xfe\x00\x00\x00\x00\xa6\xfe\x1c\xfe\x6d\xfd\xe9\xfe\x70\xfd\x00\x00\xa4\xfe\x00\x00\x0e\xfe\x00\x00\x16\xff\x00\x00\x00\x00\x4b\xfe\x37\xfe\x25\xff\xc7\xfc\x5d\xff\x36\xfe\x34\xfe\x00\x00\x37\xfe\x00\x00\x00\x00\x94\xfe\x00\x00\xe0\xfe\x22\xfe\x00\x00\xf5\xfe\xf8\xfe\xf8\xfe\x4f\xfe\x50\xfe\x50\xfe\x23\xff\x13\xff\xeb\xfe\xee\xfe\xee\xfe\x0e\xff\x20\xff\x21\xff\x40\xff\x00\x00\x35\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb9\xfe\x4b\xfd\x00\x00\x06\xff\x09\xff\x00\x00\x00\x00\xce\xfe\xcd\xfe\x00\x00\x00\x00\xd5\xfe\xd3\xfe\x00\x00\xc0\xfe\x00\x00\xbb\xfe\x00\x00\x82\xff\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\x8e\xff\x00\x00\xbe\xff\xbd\xff\x00\x00\x7f\xff\xbf\xfe\xd4\xfe\x00\x00\x00\x00\xcf\xfe\xd1\xfe\xe6\xfe\xe6\xfe\x02\xff\xad\xfe\x00\x00\x9b\xfe\x00\x00\x44\xff\x00\x00\x5e\xff\x00\x00\xf3\xfe\x2d\xff\xef\xfe\x00\x00\xf2\xfe\x28\xff\x2d\xff\x00\x00\x53\xfe\x51\xfe\xfe\xfe\xf9\xfe\x00\x00\xfd\xfe\x2f\xff\x00\x00\x00\x00\x00\x00\x1e\xfe\x96\xfe\x8a\xfe\x48\xfe\x48\xfe\x5c\xff\x00\x00\x33\xfe\x36\xfd\x30\xfe\x4c\xff\x4e\xff\x4d\xff\x00\x00\x35\xfe\x44\xfe\x42\xfe\x3e\xfe\x55\xff\x37\xfe\x18\xff\x00\x00\x14\xfe\x15\xfe\x00\x00\x89\xfe\xae\xfd\xa7\xfd\xa6\xfd\xa9\xfd\x00\x00\x00\x00\x00\x00\x96\xfd\x91\xfd\x92\xfd\x00\x00\x00\x00\x69\xfe\x3a\xfe\x38\xfe\x56\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\x3e\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\xeb\xfc\x85\xff\x00\x00\xcf\xff\x00\x00\x00\x00\xa2\xfd\xa1\xfd\x00\x00\xa3\xfe\x00\x00\x19\xff\x54\xff\x00\x00\x58\xfe\x00\x00\x61\xfe\x00\x00\x2f\xfe\x35\xfd\x31\xfe\x32\xfe\x00\x00\x49\xfe\x46\xfe\x00\x00\x00\x00\x00\x00\xf7\xfe\xfa\xfe\x31\xff\x1f\xff\x00\x00\x00\x00\x00\x00\x00\x00\x2e\xff\xf6\xfe\xed\xfe\xf0\xfe\x00\x00\x2c\xff\xec\xfe\x14\xff\x3f\xff\x37\xff\x37\xff\x00\x00\x00\x00\xae\xfe\x00\x00\x00\x00\xce\xfe\x00\x00\xda\xfe\x7d\xff\xc5\xff\x8b\xff\x8b\xff\xc4\xff\x00\x00\x00\x00\x7b\xff\x00\x00\x00\x00\x00\x00\x01\xff\x00\xff\x36\xff\x43\xff\x41\xff\x00\x00\x38\xff\x00\x00\x00\x00\x00\x00\x00\x00\x2b\xff\xf1\xfe\x24\xff\x00\x00\x1f\xff\x30\xff\x33\xff\x00\x00\x00\x00\xfb\xfe\x4d\xfe\x00\x00\x00\x00\x48\xfe\x4c\xfe\x2e\xfe\x00\x00\xc9\xfc\x00\x00\x00\x00\x91\xfe\x3d\xfe\x87\xfe\x85\xfe\x40\xfe\x84\xfe\x00\x00\x00\x00\x00\x00\xee\xfd\xc8\xff\x00\x00\xc6\xff\x00\x00\xc7\xff\x00\x00\xce\xff\xa7\xff\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\x3d\xfd\x3c\xfd\x3b\xfd\x00\x00\xd3\xff\xd1\xff\x00\x00\xe3\xff\x00\x00\xc9\xff\xa8\xff\x00\x00\xa0\xfd\x1a\xff\x86\xfe\x00\x00\x3f\xfe\xc7\xfc\x60\xfe\x4a\xfe\x45\xfe\x47\xfe\x00\x00\x78\xfe\x00\x00\x1e\xff\x32\xff\x00\x00\xfc\xfe\x34\xff\x26\xff\x3c\xff\x3e\xff\x39\xff\x3b\xff\x3d\xff\x42\xff\xd2\xfe\xcc\xfe\x7e\xff\x87\xff\x7c\xff\x00\x00\xa1\xff\xbb\xff\xba\xff\x00\x00\xa1\xff\x3a\xff\x4b\xfe\x37\xfe\x78\xfe\x00\x00\x43\xfe\x3d\xfe\x41\xfe\xfa\xfd\x00\x00\xa8\xff\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\x1d\xff\x2a\xff\x37\xfe\x00\x00\x7a\xff\x79\xff\x29\xff\xca\xff\x00\x00\x00\x00\x00\x00\xe1\xff\xdf\xff\xe0\xff\xcb\xff"#  happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x00\x00\x0d\x00\x53\x00\x05\x00\x06\x00\x23\x00\x24\x00\x06\x00\x39\x00\x0f\x00\x10\x00\x0f\x00\x10\x00\x13\x00\x11\x00\x13\x00\x13\x00\x53\x00\x10\x00\x0c\x00\x0d\x00\x13\x00\x12\x00\x13\x00\x14\x00\x13\x00\x14\x00\x53\x00\x18\x00\x08\x00\x09\x00\x0a\x00\x61\x00\x1b\x00\x04\x00\x1d\x00\x3a\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\x64\x00\x61\x00\x21\x00\x22\x00\x23\x00\x24\x00\x21\x00\x22\x00\x23\x00\x24\x00\x9a\x00\x21\x00\x22\x00\x23\x00\x24\x00\x82\x00\x83\x00\x22\x00\x23\x00\x24\x00\x3b\x00\x3c\x00\x23\x00\x24\x00\x3b\x00\x3c\x00\x23\x00\x24\x00\x44\x00\xac\x00\xad\x00\xb1\x00\xb2\x00\x13\x00\x00\x00\x13\x00\x00\x00\x13\x00\x48\x00\xab\x00\x77\x00\x78\x00\x01\x00\x77\x00\x78\x00\xd5\x00\xe7\x00\x48\x00\x11\x00\xc1\x00\x36\x00\xd5\x00\x00\x00\x19\x00\xab\x00\x4f\x00\x52\x00\x19\x00\x52\x00\x0a\x00\x54\x00\xcd\x00\x56\x00\x11\x00\xab\x00\x00\x00\x52\x00\x35\x00\x4e\x00\x4f\x00\x25\x00\x35\x00\x36\x00\x4b\x00\x4b\x00\x2a\x00\x2b\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x49\x00\x29\x00\x2a\x00\x2b\x00\x54\x00\x01\x00\x56\x00\xbe\x00\x3f\x00\x40\x00\xc1\x00\x4b\x00\xc3\x00\x70\x00\xc5\x00\x3f\x00\x40\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x0c\x00\xcd\x00\xce\x00\x70\x00\x15\x00\x87\x00\x6f\x00\x61\x00\x88\x00\x61\x00\x52\x00\x45\x00\x2d\x01\x4b\x00\x52\x00\x4b\x00\x1c\x00\x0c\x00\x0a\x01\x0b\x01\x7e\x00\x87\x00\x0e\x01\x62\x00\x10\x01\x4f\x00\x6f\x00\x87\x00\x65\x00\x69\x00\x64\x00\x2f\x01\x64\x00\x31\x01\x1a\x01\x88\x00\x1c\x01\x2f\x01\xb6\x00\x77\x00\x78\x00\x6f\x00\x62\x00\xf7\x00\xf8\x00\x87\x00\x26\x01\x87\x00\x64\x00\x87\x00\x69\x00\x6f\x00\x73\x00\x01\x01\x02\x01\x61\x00\x32\x01\x05\x01\x06\x01\x32\x01\x62\x00\x64\x00\x38\x01\x75\x00\x7e\x00\x38\x01\x1d\x01\xd2\x00\x20\x01\x20\x01\x32\x01\xd2\x00\x6f\x00\x6a\x00\x26\x01\x26\x01\x38\x01\x60\x00\x64\x00\x70\x00\xbd\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x32\x01\x07\x01\x65\x00\x20\x01\x6f\x00\x26\x01\x38\x01\x28\x01\x29\x01\x26\x01\x32\x01\x2c\x01\x87\x00\x13\x01\x14\x01\x1c\x01\x38\x01\x01\x01\x02\x01\x83\x00\x20\x01\x05\x01\x06\x01\x20\x01\x08\x01\x26\x01\x26\x01\x7e\x00\x88\x00\x26\x01\x24\x01\x25\x01\x4d\x00\x27\x01\x79\x00\x7a\x00\x32\x01\x2b\x01\x34\x01\x35\x01\x18\x01\x0e\x01\x0f\x01\x10\x01\x13\x00\x83\x00\x1e\x01\x1f\x01\x20\x01\x21\x01\x2e\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2e\x01\x1c\x01\x70\x00\x2e\x01\x36\x01\x88\x00\x36\x01\x36\x01\x71\x00\x2e\x01\x1c\x01\x26\x01\x36\x01\x76\x00\x36\x01\x26\x01\x36\x01\x6a\x00\x35\x00\x7a\x00\x26\x01\x19\x00\x07\x01\x70\x00\x26\x01\x87\x00\x32\x01\x26\x01\x34\x01\x35\x01\x32\x01\x26\x01\x34\x01\x35\x01\x26\x01\x32\x01\x7c\x00\x34\x01\x35\x01\xad\x00\x32\x01\x2d\x00\x34\x01\x35\x01\x32\x01\x1c\x01\x34\x01\x35\x01\x32\x01\x87\x00\x34\x01\x35\x01\x0c\x01\x00\x00\x0e\x01\x26\x01\x10\x01\x0c\x01\x2b\x01\x0e\x01\x4d\x00\x10\x01\x0c\x01\x20\x01\x0e\x01\x1d\x01\x10\x01\x4e\x00\x20\x01\x26\x01\x1e\x01\x1f\x01\x20\x01\x00\x00\x26\x01\x1e\x01\x1f\x01\x20\x01\x26\x01\x00\x00\x1e\x01\x1f\x01\x20\x01\x26\x01\x1d\x01\x39\x00\x66\x00\x20\x01\x26\x01\x3d\x00\x3e\x00\x3f\x00\x40\x00\x26\x01\x42\x00\x03\x01\x04\x01\x05\x01\x06\x01\x66\x00\x6a\x00\x70\x00\xa0\x00\xa1\x00\x00\x00\x97\x00\x70\x00\xfe\x00\xff\x00\x70\x00\x52\x00\x7f\x00\x03\x01\x1d\x01\x05\x01\x06\x01\x20\x01\x1d\x01\x5a\x00\x5b\x00\x20\x01\x8a\x00\x26\x01\x5f\x00\x20\x01\xa1\x00\x26\x01\x00\x00\x64\x00\x92\x00\x26\x01\x58\x00\x52\x00\x29\x01\x97\x00\x98\x00\x99\x00\x9a\x00\x1d\x01\x1d\x01\x34\x00\x20\x01\x20\x01\x00\x00\xb0\x00\xb1\x00\xb2\x00\x26\x01\x26\x01\x97\x00\x29\x01\xfe\x00\xff\x00\x64\x00\x1d\x01\x7f\x00\x03\x01\x20\x01\x05\x01\x06\x01\x75\x00\x00\x00\x70\x00\x26\x01\x6f\x00\x4e\x00\xfe\x00\xff\x00\x4e\x00\x58\x00\x7f\x00\x03\x01\x32\x01\x05\x01\x06\x01\x4e\x00\xc1\x00\x52\x00\x38\x01\x64\x00\x6c\x00\x9a\x00\x1d\x01\x4c\x00\x70\x00\x20\x01\xa0\x00\xa1\x00\xcd\x00\x52\x00\x6f\x00\x26\x01\x62\x00\xb6\x00\x29\x01\xa0\x00\xa1\x00\x1d\x01\x75\x00\x70\x00\x20\x01\x6a\x00\x70\x00\x4e\x00\x64\x00\x6f\x00\x26\x01\x70\x00\x7f\x00\x29\x01\xa1\x00\xb7\x00\xb8\x00\xb9\x00\x41\x00\x6f\x00\xa0\x00\xa1\x00\xbe\x00\x70\x00\xc1\x00\xc1\x00\x56\x00\xc3\x00\x1a\x01\xc5\x00\x1c\x01\x64\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcd\x00\xcd\x00\xce\x00\x39\x00\x26\x01\x70\x00\x6f\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x64\x00\x42\x00\x13\x00\x1a\x01\x1e\x00\x1c\x01\x0a\x01\x0b\x01\x4c\x00\x0d\x01\x0e\x01\x6f\x00\x10\x01\x11\x01\x12\x01\x26\x01\x54\x00\x52\x00\x64\x00\x2d\x00\xa0\x00\xa1\x00\x1a\x01\x1b\x01\x1c\x01\x5a\x00\x5b\x00\xa0\x00\xa1\x00\x6f\x00\x5f\x00\x32\x01\xf7\x00\xf8\x00\x26\x01\x64\x00\x35\x00\x38\x01\x0e\x01\x0f\x01\x10\x01\x19\x00\x01\x01\x02\x01\x8a\x00\x57\x00\x05\x01\x06\x01\x5a\x00\x6a\x00\x0a\x01\x0b\x01\x92\x00\x5f\x00\x0e\x01\x70\x00\x10\x01\x97\x00\x98\x00\x99\x00\x9a\x00\x2d\x00\x7f\x00\x7b\x00\x7c\x00\x1a\x01\x1a\x01\x1c\x01\x1c\x01\x4d\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1a\x01\x75\x00\x1c\x01\x26\x01\x26\x01\x26\x01\x4f\x00\x28\x01\x29\x01\x74\x00\x53\x00\x2c\x01\x26\x01\x78\x00\x1a\x01\x52\x00\x1c\x01\x32\x01\x33\x01\x34\x01\x35\x01\x1a\x01\x19\x00\x1c\x01\x6a\x00\xc1\x00\x26\x01\x57\x00\xa0\x00\xa1\x00\x70\x00\x62\x00\x54\x00\x26\x01\x56\x00\x19\x00\x76\x00\xcd\x00\xf3\x00\xf4\x00\x7a\x00\x4e\x00\x2d\x00\x52\x00\xb7\x00\xb8\x00\xb9\x00\x39\x00\x4b\x00\x11\x01\x12\x01\xbe\x00\xaa\x00\x6c\x00\xc1\x00\x2d\x00\xc3\x00\x70\x00\xc5\x00\x1e\x00\x4b\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x73\x00\xcd\x00\xce\x00\x1a\x01\x6c\x00\x1c\x01\x51\x00\x52\x00\x70\x00\x2d\x00\x1a\x01\x7e\x00\x1c\x01\x8a\x00\x2f\x01\x26\x01\x1e\x01\x1f\x01\x20\x01\x90\x00\x5f\x00\x92\x00\x26\x01\x1e\x00\x26\x01\x64\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x69\x00\x6a\x00\x84\x00\x0a\x01\x0b\x01\x14\x00\x0d\x01\x0e\x01\x2d\x00\x10\x01\x11\x01\x12\x01\x32\x01\xf7\x00\xf8\x00\x0e\x01\x97\x00\x10\x01\x38\x01\x1a\x01\x1b\x01\x1c\x01\x1a\x00\x01\x01\x02\x01\xfe\x00\xff\x00\x05\x01\x06\x01\x1c\x01\x03\x01\x26\x01\x05\x01\x06\x01\x31\x00\x32\x00\x33\x00\x66\x00\xc1\x00\x26\x01\x6c\x00\x14\x00\x2e\x00\x2f\x00\x70\x00\x62\x00\x03\x01\x04\x01\x05\x01\x06\x01\xcd\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1a\x01\x1d\x01\x1c\x01\x6f\x00\x20\x01\x26\x01\x1f\x00\x28\x01\x29\x01\x53\x00\x26\x01\x2c\x01\x26\x01\x29\x01\x61\x00\x31\x00\x32\x00\x32\x01\x33\x01\x34\x01\x35\x01\x2e\x00\x2f\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x20\x01\x29\x01\xbe\x00\x53\x00\x65\x00\xc1\x00\x26\x01\xc3\x00\x69\x00\xc5\x00\x6b\x00\x69\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x74\x00\x4d\x00\x20\x01\x74\x00\x51\x00\x52\x00\x1e\x00\x78\x00\x26\x01\x0a\x01\x0b\x01\x54\x00\x0d\x01\x0e\x01\x97\x00\x10\x01\x11\x01\x12\x01\x5f\x00\x55\x00\x62\x00\x2d\x00\x5f\x00\x64\x00\x69\x00\x1a\x01\x1b\x01\x1c\x01\x69\x00\x6a\x00\x6a\x00\x7e\x00\x08\x01\x6f\x00\x66\x00\x74\x00\x70\x00\x26\x01\x69\x00\x78\x00\xf7\x00\xf8\x00\x76\x00\x62\x00\x70\x00\x15\x01\x32\x01\x17\x01\x18\x01\x74\x00\x01\x01\x02\x01\x38\x01\x78\x00\x05\x01\x06\x01\x6f\x00\x21\x01\x62\x00\x23\x01\x24\x01\x25\x01\x69\x00\x27\x01\x01\x01\x02\x01\x2a\x01\x2b\x01\x05\x01\x06\x01\x62\x00\x6f\x00\x66\x00\x74\x00\xa8\x00\xa9\x00\xaa\x00\x78\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x70\x00\x6f\x00\xa8\x00\xa9\x00\xaa\x00\x26\x01\x1d\x01\x28\x01\x29\x01\x20\x01\x62\x00\x2c\x01\xf2\x00\xf3\x00\xf4\x00\x26\x01\x62\x00\x32\x01\x33\x01\x34\x01\x35\x01\x28\x01\x29\x01\x6f\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x6f\x00\x87\x00\xbe\x00\x89\x00\x8a\x00\xc1\x00\x62\x00\xc3\x00\x1a\x01\xc5\x00\x1c\x01\x7e\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x6f\x00\x26\x01\x6c\x00\xa8\x00\xa9\x00\xaa\x00\x70\x00\x7f\x00\x1e\x01\x1f\x01\x20\x01\x03\x01\x04\x01\x05\x01\x06\x01\x70\x00\x26\x01\x1a\x01\x5f\x00\x1c\x01\x97\x00\x4d\x00\x4e\x00\x64\x00\x20\x01\x03\x01\x04\x01\x05\x01\x06\x01\x26\x01\x26\x01\x57\x00\x6d\x00\x29\x01\x5a\x00\x03\x01\x04\x01\x05\x01\x06\x01\x5f\x00\xf7\x00\xf8\x00\xbb\x00\xbc\x00\xbd\x00\x03\x01\x04\x01\x05\x01\x06\x01\x29\x01\x01\x01\x02\x01\x74\x00\x70\x00\x05\x01\x06\x01\x78\x00\x71\x00\x4e\x00\x4f\x00\x30\x00\x75\x00\x76\x00\x29\x01\x65\x00\x79\x00\x7a\x00\x03\x01\x04\x01\x05\x01\x06\x01\x3b\x00\x3c\x00\x29\x01\x4c\x00\x4d\x00\x3f\x00\x40\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x32\x01\x29\x01\xa3\x00\xa4\x00\xa5\x00\x26\x01\x38\x01\x28\x01\x29\x01\x97\x00\x32\x01\x2c\x01\x03\x01\x04\x01\x05\x01\x06\x01\x38\x01\x32\x01\x33\x01\x34\x01\x35\x01\x2d\x00\x2e\x00\x29\x01\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x24\x01\x25\x01\xbe\x00\x27\x01\x65\x00\xc1\x00\x23\x00\xc3\x00\x69\x00\xc5\x00\x6b\x00\x69\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x74\x00\x20\x01\x29\x01\x52\x00\x78\x00\x54\x00\x8a\x00\x26\x01\x2b\x01\x28\x01\x29\x01\x32\x01\x2f\x01\x4f\x00\x92\x00\x7e\x00\x52\x00\x38\x01\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x64\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\x33\x01\xff\x00\x97\x00\x6d\x00\x37\x01\x03\x01\x4d\x00\x05\x01\x06\x01\xf5\x00\xf6\x00\xf7\x00\xf8\x00\x23\x01\x24\x01\x25\x01\x57\x00\x27\x01\x9a\x00\x5a\x00\x3a\x00\x01\x01\x02\x01\xff\x00\x5f\x00\x05\x01\x06\x01\x03\x01\x35\x00\x05\x01\x06\x01\x1d\x01\xc1\x00\x1d\x01\x20\x01\x6a\x00\x20\x01\x1e\x01\x1f\x01\x20\x01\x26\x01\x70\x00\x26\x01\x29\x01\xcd\x00\x26\x01\x75\x00\x76\x00\x97\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1d\x01\x2a\x01\x2b\x01\x20\x01\xc1\x00\x26\x01\x2f\x01\x28\x01\x29\x01\x26\x01\x97\x00\x2c\x01\x29\x01\x1e\x01\x1f\x01\x20\x01\xcd\x00\x32\x01\x33\x01\x34\x01\x35\x01\x26\x01\x4e\x00\x4f\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x4f\x00\x0b\x01\xbe\x00\x52\x00\x0e\x01\xc1\x00\x10\x01\xc3\x00\x61\x00\xc5\x00\x63\x00\x62\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x6f\x00\x4e\x00\x33\x01\x13\x00\x0a\x01\x0b\x01\x37\x01\x0d\x01\x0e\x01\x33\x01\x10\x01\x11\x01\x12\x01\x37\x01\x0b\x01\x4e\x00\x4f\x00\x0e\x01\x5f\x00\x10\x01\x1a\x01\x1b\x01\x1c\x01\x64\x00\x65\x00\x66\x00\x4d\x00\x02\x00\x03\x00\x0a\x01\x0b\x01\x1f\x00\x26\x01\x0e\x01\x57\x00\x10\x01\x57\x00\x5a\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\x5f\x00\x0b\x01\x5f\x00\x1a\x01\x0e\x01\x1c\x01\x10\x01\x4b\x00\x01\x01\x02\x01\x6e\x00\x6f\x00\x05\x01\x06\x01\x00\x01\x26\x01\x02\x01\x02\x00\x03\x00\x05\x01\x24\x01\x25\x01\x75\x00\x27\x01\x75\x00\x76\x00\x79\x00\x2b\x01\x79\x00\x7a\x00\x74\x00\x2f\x01\x1e\x01\x1f\x01\x20\x01\x70\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x26\x01\x65\x00\x61\x00\x1d\x01\x63\x00\x26\x01\x20\x01\x28\x01\x29\x01\x6e\x00\x6f\x00\x2c\x01\x26\x01\x4e\x00\x28\x01\x29\x01\x4f\x00\x32\x01\x33\x01\x34\x01\x35\x01\x5c\x00\x5d\x00\x5e\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x58\x00\x61\x00\xbe\x00\x63\x00\x65\x00\xc1\x00\x54\x00\xc3\x00\x69\x00\xc5\x00\x6b\x00\x4b\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x74\x00\x4e\x00\x4d\x00\x4b\x00\x78\x00\x1e\x01\x1f\x01\x20\x01\x61\x00\x54\x00\x63\x00\x11\x00\x57\x00\x26\x01\x52\x00\x5a\x00\x4d\x00\x61\x00\x5f\x00\x63\x00\x5f\x00\xbf\x00\xc0\x00\x64\x00\x65\x00\x66\x00\x57\x00\x4b\x00\x61\x00\x5a\x00\x63\x00\x8a\x00\x4b\x00\x61\x00\x5f\x00\x63\x00\x07\x01\x90\x00\x71\x00\x92\x00\xf7\x00\xf8\x00\x75\x00\x76\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x13\x01\x14\x01\x01\x01\x02\x01\x71\x00\x56\x00\x05\x01\x06\x01\x75\x00\x76\x00\xbf\x00\xc0\x00\x79\x00\x7a\x00\x1e\x01\x1f\x01\x20\x01\x24\x01\x25\x01\x61\x00\x27\x01\x63\x00\x26\x01\x61\x00\x2b\x01\x63\x00\x4c\x00\x4d\x00\x45\x00\x46\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x8f\x00\xb3\x00\xb4\x00\xb5\x00\xc1\x00\x26\x01\x7e\x00\x28\x01\x29\x01\xbf\x00\xc0\x00\x2c\x01\x46\x00\x47\x00\x48\x00\x49\x00\xcd\x00\x32\x01\x33\x01\x34\x01\x35\x01\xb3\x00\xb4\x00\xb5\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x45\x00\x61\x00\xbe\x00\x63\x00\x61\x00\xc1\x00\x63\x00\xc3\x00\x61\x00\xc5\x00\x63\x00\x54\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x1f\x01\x20\x01\x71\x00\x72\x00\x51\x00\x52\x00\x8a\x00\x26\x01\x6a\x00\x28\x01\x29\x01\xe3\x00\xe4\x00\xe5\x00\x92\x00\xe7\x00\x30\x01\x31\x01\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x64\x00\x4d\x00\xb3\x00\xb4\x00\xb5\x00\x69\x00\x0a\x01\x0b\x01\x54\x00\x0d\x01\x0e\x01\x57\x00\x10\x01\x11\x01\x12\x01\x6e\x00\x6f\x00\xf7\x00\xf8\x00\x5f\x00\xa4\x00\xa5\x00\x1a\x01\x1b\x01\x1c\x01\x11\x01\x12\x01\x01\x01\x02\x01\x65\x00\x6a\x00\x05\x01\x06\x01\x69\x00\x26\x01\x6b\x00\x70\x00\x6a\x00\xc1\x00\x6f\x00\x6a\x00\x75\x00\x76\x00\x6a\x00\x74\x00\x79\x00\x7a\x00\x23\x01\x24\x01\x25\x01\xcd\x00\x27\x01\x1f\x01\x20\x01\x6a\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x26\x01\x4e\x00\x28\x01\x29\x01\x87\x00\x26\x01\x70\x00\x28\x01\x29\x01\xf6\x00\xf7\x00\x2c\x01\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x32\x01\x33\x01\x34\x01\x35\x01\xb3\x00\xb4\x00\xb5\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x4b\x00\x73\x00\xbe\x00\x75\x00\x61\x00\xc1\x00\x63\x00\xc3\x00\x61\x00\xc5\x00\x63\x00\x52\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x61\x00\x4e\x00\x63\x00\x70\x00\x0a\x01\x0b\x01\x0d\x00\x0d\x01\x0e\x01\x66\x00\x10\x01\x11\x01\x12\x01\xb3\x00\xb4\x00\xb5\x00\x36\x00\x37\x00\x5f\x00\x9a\x00\x1a\x01\x1b\x01\x1c\x01\x64\x00\x65\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\x61\x00\xff\x00\x63\x00\x26\x01\xe5\x00\x03\x01\xe7\x00\x05\x01\x06\x01\x91\x00\x8f\x00\xf7\x00\xf8\x00\x09\x01\x0a\x01\x0b\x01\x8f\x00\x6c\x00\x0e\x01\x8f\x00\x10\x01\x01\x01\x02\x01\x6a\x00\x66\x00\x05\x01\x06\x01\x70\x00\x7f\x00\xc1\x00\x1a\x01\x1d\x01\x1c\x01\x4b\x00\x20\x01\xb3\x00\xb4\x00\xb5\x00\x4b\x00\x54\x00\x26\x01\xcd\x00\x26\x01\x29\x01\x4b\x00\x0d\x00\x6f\x00\x52\x00\x15\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x71\x00\x71\x00\x6a\x00\x6a\x00\x6a\x00\x26\x01\x71\x00\x28\x01\x29\x01\x6c\x00\x6a\x00\x2c\x01\x71\x00\x6a\x00\x6c\x00\x62\x00\x0c\x00\x32\x01\x33\x01\x34\x01\x35\x01\x34\x00\x19\x00\x57\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x6f\x00\x4e\x00\xbe\x00\x70\x00\x70\x00\xc1\x00\x71\x00\xc3\x00\x6a\x00\xc5\x00\x6a\x00\x6a\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x6a\x00\x0a\x01\x0b\x01\x6a\x00\x6a\x00\x0e\x01\x6a\x00\x10\x01\x09\x01\x0a\x01\x0b\x01\x6a\x00\x62\x00\x0e\x01\x66\x00\x10\x01\x4f\x00\x1a\x01\x5f\x00\x1c\x01\x4d\x00\x4e\x00\x70\x00\x64\x00\x54\x00\x70\x00\x17\x00\x70\x00\x4d\x00\x26\x01\x57\x00\x54\x00\x6d\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x70\x00\xf7\x00\xf8\x00\x52\x00\x62\x00\x6a\x00\x23\x01\x24\x01\x25\x01\x70\x00\x27\x01\x01\x01\x02\x01\x2a\x01\x2b\x01\x05\x01\x06\x01\x71\x00\x2f\x01\x56\x00\x4e\x00\x75\x00\x76\x00\x4f\x00\x4b\x00\x79\x00\x7a\x00\x4b\x00\x4e\x00\x7f\x00\x66\x00\x4e\x00\x4b\x00\x6a\x00\x70\x00\x6a\x00\x4d\x00\x4b\x00\x71\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x71\x00\x56\x00\x52\x00\x4e\x00\x19\x00\x26\x01\x4e\x00\x28\x01\x29\x01\x6a\x00\x19\x00\x2c\x01\x4f\x00\x74\x00\x1a\x00\x7e\x00\x4b\x00\x32\x01\x33\x01\x34\x01\x35\x01\x7e\x00\x4b\x00\x16\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x0c\x00\x7e\x00\xbe\x00\x69\x00\x6f\x00\xc1\x00\x4b\x00\xc3\x00\x66\x00\xc5\x00\x19\x00\x62\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\x70\x00\xff\x00\x8a\x00\x4e\x00\x71\x00\x03\x01\x4e\x00\x05\x01\x06\x01\x4e\x00\x92\x00\x5f\x00\x4e\x00\x4e\x00\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x64\x00\xfc\x00\xfd\x00\x52\x00\xff\x00\x70\x00\x4f\x00\x19\x00\x03\x01\x6d\x00\x05\x01\x06\x01\x1d\x01\x54\x00\x19\x00\x20\x01\x07\x00\xf7\x00\xf8\x00\x24\x01\x25\x01\x26\x01\x27\x01\x4f\x00\x29\x01\x56\x00\x2b\x01\x01\x01\x02\x01\x4b\x00\x2f\x01\x05\x01\x06\x01\x52\x00\x1d\x01\x66\x00\x7b\x00\x20\x01\xc1\x00\x54\x00\x62\x00\x52\x00\x6f\x00\x26\x01\x6a\x00\x6f\x00\x29\x01\x7f\x00\x19\x00\x66\x00\xcd\x00\x19\x00\x6f\x00\x69\x00\x88\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x6a\x00\x88\x00\x87\x00\x6a\x00\x57\x00\x26\x01\x19\x00\x28\x01\x29\x01\x52\x00\x2d\x00\x2c\x01\x4f\x00\x6f\x00\x4b\x00\x70\x00\x4b\x00\x32\x01\x33\x01\x34\x01\x35\x01\x5f\x00\x19\x00\x07\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x07\x00\x19\x00\xbe\x00\x4e\x00\x87\x00\xc1\x00\x5f\x00\xc3\x00\x66\x00\xc5\x00\x7e\x00\x19\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x4b\x00\x4b\x00\x19\x00\x16\x00\x0a\x01\x0b\x01\x6f\x00\x0d\x01\x0e\x01\x4e\x00\x10\x01\x11\x01\x12\x01\x1a\x00\x4f\x00\x11\x00\x54\x00\x23\x00\x5f\x00\x88\x00\x1a\x01\x1b\x01\x1c\x01\x64\x00\x4d\x00\x4e\x00\x4f\x00\x33\x00\x1a\x00\x52\x00\x07\x00\x7f\x00\x26\x01\x09\x00\x57\x00\x6a\x00\x3a\x00\x5a\x00\x65\x00\x69\x00\xf7\x00\xf8\x00\x5f\x00\x69\x00\x56\x00\x2e\x00\x4d\x00\x52\x00\x70\x00\x6a\x00\x01\x01\x02\x01\x6f\x00\x4e\x00\x05\x01\x06\x01\x6f\x00\x62\x00\x45\x00\x02\x00\x71\x00\x4d\x00\x62\x00\x4e\x00\x75\x00\x76\x00\x6a\x00\x5f\x00\x79\x00\x7a\x00\x02\x00\x62\x00\x56\x00\x7f\x00\x5f\x00\x88\x00\x6a\x00\x6a\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x52\x00\x4b\x00\x4d\x00\x87\x00\x6a\x00\x26\x01\x52\x00\x28\x01\x29\x01\x19\x00\x07\x00\x2c\x01\x6a\x00\x70\x00\x6a\x00\x69\x00\x69\x00\x32\x01\x33\x01\x34\x01\x35\x01\x70\x00\x4e\x00\x19\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x01\x01\x02\x01\x75\x00\xbe\x00\x05\x01\x06\x01\xc1\x00\x4d\x00\xc3\x00\x69\x00\xc5\x00\x4d\x00\x8a\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x92\x00\x19\x00\x07\x00\x6a\x00\x75\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x1e\x01\x1f\x01\x20\x01\x30\x00\xec\x00\xec\x00\x8a\x00\x2f\x01\x26\x01\xec\x00\x28\x01\x29\x01\xd1\x00\x38\x00\x92\x00\x59\x00\x43\x00\x80\x00\x31\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x2d\x01\x32\x00\x2e\x01\x2e\x01\x10\x01\x7d\x00\x7d\x00\x85\x00\xf7\x00\xf8\x00\xa2\x00\x59\x00\x81\x00\x81\x00\x74\x00\xc1\x00\x8a\x00\x2f\x01\x01\x01\x02\x01\x2d\x01\x16\x00\x05\x01\x06\x01\x92\x00\x8b\x00\x2e\x01\xcd\x00\x2e\x01\x97\x00\x98\x00\x99\x00\x9a\x00\xc6\x00\x16\x00\x30\x00\x2d\x01\x03\x00\xc1\x00\xcf\x00\x2d\x01\x4d\x00\x4e\x00\x33\x01\x2d\x01\x33\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\xcd\x00\x57\x00\x2d\x01\x68\x00\x5a\x00\x26\x01\x54\x00\x28\x01\x29\x01\x5f\x00\x43\x00\x2c\x01\xdf\x00\x6c\x00\xdf\x00\xe7\x00\x55\x00\x32\x01\x33\x01\x34\x01\x35\x01\xc1\x00\x76\x00\x74\x00\x72\x00\x29\x01\x7e\x00\x71\x00\x34\x00\x16\x00\x16\x00\x75\x00\x76\x00\xcd\x00\x2c\x00\x79\x00\x7a\x00\x20\x00\x0a\x01\x0b\x01\x7d\x00\x0d\x01\x0e\x01\x7d\x00\x10\x01\x11\x01\x12\x01\x20\x00\x33\x00\x63\x00\x47\x00\x5e\x00\x6b\x00\x70\x00\x1a\x01\x1b\x01\x1c\x01\x67\x00\x8a\x00\xa7\x00\x8b\x00\x0a\x01\x0b\x01\x8b\x00\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\x57\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x4d\x00\x2c\x00\x1a\x01\x1b\x01\x1c\x01\x0e\x00\x20\x00\x20\x00\xc6\x00\x70\x00\x57\x00\xe7\x00\xb5\x00\x5a\x00\x26\x01\x58\x00\xa5\x00\xa7\x00\x5f\x00\x0a\x01\x0b\x01\x4a\x00\x0d\x01\x0e\x01\x2e\x01\x10\x01\x11\x01\x12\x01\x17\x00\x2d\x01\x17\x00\x34\x00\x50\x00\x4b\x00\x2d\x01\x1a\x01\x1b\x01\x1c\x01\xc1\x00\x50\x00\x75\x00\x76\x00\x4f\x00\x2d\x01\x79\x00\x7a\x00\x8a\x00\x26\x01\x2d\x01\x45\x00\xcd\x00\x33\x01\x90\x00\x1c\x00\x92\x00\xae\x00\x1c\x00\x26\x00\x0b\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x31\x00\x2e\x01\x8a\x00\x2e\x01\x2d\x01\x56\x00\x2d\x01\x59\x00\x90\x00\x2d\x01\x92\x00\x35\x00\x56\x00\x2e\x01\x2d\x01\x97\x00\x98\x00\x99\x00\x9a\x00\x54\x00\x2d\x01\x16\x00\x2e\x01\x16\x00\x20\x00\xa7\x00\x20\x00\x86\x00\x87\x00\x2e\x01\x2e\x01\x8a\x00\x17\x00\x2e\x01\x17\x00\x8e\x00\x8f\x00\x90\x00\xc1\x00\x92\x00\x93\x00\x2e\x01\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x0a\x01\x0b\x01\xcd\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x87\x00\xff\xff\xc1\x00\x8a\x00\x54\x00\xff\xff\xff\xff\x57\x00\x8f\x00\x90\x00\x5a\x00\xff\xff\x93\x00\xff\xff\xcd\x00\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x70\x00\x10\x01\x11\x01\x12\x01\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xf7\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x26\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xf7\x00\xff\xff\x93\x00\x32\x01\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\x87\x00\x26\x01\xc1\x00\x8a\x00\x5f\x00\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\x32\x01\xcd\x00\x6a\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\x87\x00\x79\x00\x7a\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\x4d\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xf7\x00\x5a\x00\xc1\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\x03\x01\xcd\x00\x05\x01\x06\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x71\x00\x10\x01\x11\x01\x12\x01\x75\x00\x76\x00\xff\xff\xc1\x00\x79\x00\x7a\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x1d\x01\xff\xff\xff\xff\x20\x01\xcd\x00\xff\xff\xff\xff\xff\xff\x26\x01\x26\x01\xff\xff\xff\xff\x29\x01\xff\xff\xff\xff\xff\xff\x87\x00\xf7\x00\xff\xff\x8a\x00\x32\x01\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\x32\x01\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\x87\x00\xd0\x00\x26\x01\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\x32\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\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\x8a\x00\xff\xff\xff\xff\xff\xff\xf7\x00\x8f\x00\x90\x00\xf7\x00\xf8\x00\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x26\x01\xc1\x00\x28\x01\x29\x01\x8a\x00\xff\xff\x2c\x01\xff\xff\x08\x01\x32\x01\xff\xff\x91\x00\xff\xff\xcd\x00\x94\x00\x95\x00\x96\x00\xff\xff\xff\xff\x99\x00\x9a\x00\x15\x01\xff\xff\x17\x01\x18\x01\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x01\xff\xff\x23\x01\x24\x01\x25\x01\xff\xff\x27\x01\xff\xff\xaf\x00\x2a\x01\x2b\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x26\x01\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\x26\x01\x99\x00\x9a\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\x99\x00\x9a\x00\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x57\x00\xff\xff\xff\xff\x5a\x00\x26\x01\xff\xff\xc1\x00\x8a\x00\x5f\x00\xff\xff\xff\xff\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x93\x00\x33\x01\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\x33\x01\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\x8a\x00\xff\xff\x33\x01\xff\xff\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xcd\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x9c\x00\xff\xff\x32\x01\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\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xf7\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x9c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xcd\x00\x10\x01\x11\x01\x12\x01\x4d\x00\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xc1\x00\xff\xff\xff\xff\x5f\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xf7\x00\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\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\xff\xff\x02\x01\xff\xff\xc1\x00\x05\x01\xff\xff\xff\xff\x08\x01\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xcd\x00\xff\xff\x93\x00\xff\xff\x14\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x1d\x01\xff\xff\xff\xff\x20\x01\xc1\x00\x08\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xff\xff\xcd\x00\xff\xff\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\x21\x01\xff\xff\x23\x01\x24\x01\x25\x01\xc1\x00\x27\x01\xff\xff\xff\xff\x2a\x01\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x32\x01\xf7\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x32\x01\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\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x08\x01\x8f\x00\x90\x00\xcd\x00\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x01\xff\xff\x23\x01\x24\x01\x25\x01\xff\xff\x27\x01\xcd\x00\xff\xff\x2a\x01\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x32\x01\xf7\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xc1\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\x9f\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xf7\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\xff\xff\xff\xff\x2a\x01\x2b\x01\xff\xff\xff\xff\xff\xff\x2f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x2f\x01\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x2f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\x8a\x00\xcd\x00\x02\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\x0a\x00\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xc1\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xf7\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xcd\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x2f\x01\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\x7e\x00\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xc1\x00\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xc1\x00\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x9d\x00\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x9d\x00\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x9f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\xa6\x00\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xc1\x00\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x92\x00\x10\x01\x11\x01\x12\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xcd\x00\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\x26\x01\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x92\x00\x10\x01\x11\x01\x12\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\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\xc1\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x99\x00\x9a\x00\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xc1\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\x26\x01\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x40\x00\xff\xff\xff\xff\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\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\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x93\x00\x94\x00\x95\x00\x96\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\x0a\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\x0a\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\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\x36\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\x01\x00\x02\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xff\xff\x90\x00\x0a\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x01\x00\x02\x00\x7e\x00\x7f\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\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\x11\x00\xff\xff\x95\x00\x96\x00\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x01\x00\x02\x00\x7e\x00\x7f\x00\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x0a\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x1e\x01\x1f\x01\x20\x01\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x26\x01\x6b\x00\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\x39\x01\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x0a\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x1e\x01\x1f\x01\x20\x01\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x26\x01\x6b\x00\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\x39\x01\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\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\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x0a\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x1e\x01\x1f\x01\x20\x01\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x26\x01\x6b\x00\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\x39\x01\x7e\x00\x7f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\xc1\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\x0a\x00\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x1e\x01\x1f\x01\x20\x01\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x26\x01\x6b\x00\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x88\x00\xff\xff\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\x1e\x01\x1f\x01\x20\x01\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x26\x01\x6b\x00\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x79\x00\x7a\x00\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\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\x16\x00\x92\x00\xff\xff\xff\xff\x95\x00\x96\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x02\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\x0a\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\x36\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\x73\x00\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x7e\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7e\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\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7e\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\x36\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\x73\x00\x74\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7e\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\x36\x00\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\x7e\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\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\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x0a\x00\xff\xff\xff\xff\x3a\x01\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\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\x3a\x01\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xff\xff\x2f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x39\x01\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xff\xff\x2f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x39\x01\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\x02\x00\xff\xff\x2f\x01\xc1\x00\x31\x01\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\x39\x01\xcb\x00\xff\xff\xcd\x00\xce\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x26\x01\x6b\x00\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x71\x00\xff\xff\x73\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\xff\xff\x7a\x00\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x02\x00\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\x0a\x00\xff\xff\xff\xff\xd7\x00\xd8\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\xff\xff\x2c\x00\xf7\x00\xf8\x00\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x69\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\xce\x00\xff\xff\x73\x00\x74\x00\xff\xff\xd3\x00\x77\x00\x78\x00\xd6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xff\xff\xff\xff\xd6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd9\x00\xda\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe0\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xda\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x2d\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xef\x00\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xdd\x00\xde\x00\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe0\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xdd\x00\xde\x00\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe0\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe5\x00\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xdc\x00\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xe2\x00\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\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\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x39\x01\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\x36\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\x36\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\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\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\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\x69\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\x02\x00\x77\x00\x78\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\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\x65\x00\xff\xff\x2c\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\x73\x00\x74\x00\xff\xff\x02\x00\x77\x00\x78\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\x4c\x00\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\x69\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\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\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\x36\x00\xff\xff\x65\x00\x02\x00\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\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\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\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\x36\x00\xff\xff\x65\x00\x02\x00\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\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\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x78\x00\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\x36\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\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\x78\x00\x4c\x00\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\x69\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\x77\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x02\x00\xff\xff\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x0a\x00\xff\xff\x70\x00\xff\xff\xff\xff\x73\x00\x74\x00\x75\x00\x76\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\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\x36\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x02\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\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\x65\x00\xff\xff\x2c\x00\xff\xff\x69\x00\x02\x00\x6b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\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\x36\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x02\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\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\x65\x00\xff\xff\x2c\x00\xff\xff\x69\x00\x02\x00\x6b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\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\x36\x00\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x69\x00\x02\x00\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\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\x65\x00\xff\xff\x2c\x00\xff\xff\x69\x00\x02\x00\x6b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x36\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\x73\x00\x74\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x0a\x00\xff\xff\xff\xff\x53\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\x61\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\x70\x00\xff\xff\x2c\x00\x73\x00\xff\xff\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x73\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x69\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\x0a\x00\xc5\x00\xff\xff\x73\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\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\x36\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\x69\x00\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xc1\x00\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\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\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xea\x00\xeb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xc1\x00\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\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\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xea\x00\xeb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xc1\x00\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\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\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xea\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\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\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#+happyCheck = HappyA# "\xff\xff\x00\x00\x0d\x00\x53\x00\x05\x00\x06\x00\x23\x00\x24\x00\x06\x00\x39\x00\x0f\x00\x10\x00\x0f\x00\x10\x00\x13\x00\x11\x00\x13\x00\x13\x00\x53\x00\x10\x00\x0c\x00\x0d\x00\x13\x00\x12\x00\x13\x00\x14\x00\x13\x00\x14\x00\x53\x00\x18\x00\x08\x00\x09\x00\x0a\x00\x61\x00\x1b\x00\x04\x00\x1d\x00\x3a\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\x64\x00\x61\x00\x21\x00\x22\x00\x23\x00\x24\x00\x21\x00\x22\x00\x23\x00\x24\x00\x9a\x00\x21\x00\x22\x00\x23\x00\x24\x00\x82\x00\x83\x00\x22\x00\x23\x00\x24\x00\x3b\x00\x3c\x00\x23\x00\x24\x00\x3b\x00\x3c\x00\x23\x00\x24\x00\x44\x00\xac\x00\xad\x00\xb1\x00\xb2\x00\x01\x00\x00\x00\x13\x00\x00\x00\x13\x00\x48\x00\xab\x00\x77\x00\x78\x00\x13\x00\x77\x00\x78\x00\xd5\x00\x36\x00\x48\x00\x11\x00\xc1\x00\x85\x00\xd5\x00\x70\x00\x19\x00\xab\x00\x00\x00\x11\x00\x0c\x00\x52\x00\x00\x00\x0a\x00\xcd\x00\x19\x00\x4b\x00\xab\x00\x4b\x00\x52\x00\x00\x00\x07\x01\x35\x00\x25\x00\x35\x00\x36\x00\x1c\x00\x4f\x00\x2a\x00\x2b\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x00\x00\x49\x00\x29\x00\x2a\x00\x2b\x00\x13\x00\x68\x00\x52\x00\xbe\x00\x3f\x00\x40\x00\xc1\x00\x6e\x00\xc3\x00\x4b\x00\xc5\x00\x62\x00\x52\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x2b\x01\xcd\x00\xce\x00\xe7\x00\x45\x00\x85\x00\x73\x00\x0c\x00\x7c\x00\x61\x00\x7c\x00\x62\x00\x52\x00\x6e\x00\x4c\x00\x52\x00\x61\x00\x35\x00\x0a\x01\x0b\x01\x52\x00\x85\x00\x0e\x01\x62\x00\x10\x01\xbd\x00\x6d\x00\x67\x00\x65\x00\x85\x00\x64\x00\x2f\x01\x64\x00\x31\x01\x1a\x01\x1e\x00\x1c\x01\x2f\x01\xb6\x00\x77\x00\x78\x00\x71\x00\x62\x00\xf7\x00\xf8\x00\x85\x00\x26\x01\x85\x00\x6e\x00\x67\x00\x2d\x00\x64\x00\x85\x00\x01\x01\x02\x01\x64\x00\x32\x01\x05\x01\x06\x01\x32\x01\x6d\x00\x52\x00\x38\x01\x64\x00\x6d\x00\x38\x01\x1d\x01\xd2\x00\x20\x01\x20\x01\x32\x01\xd2\x00\x6d\x00\x2d\x01\x26\x01\x26\x01\x38\x01\x60\x00\x64\x00\x61\x00\x4e\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x32\x01\x07\x01\x6d\x00\x20\x01\x6e\x00\x26\x01\x38\x01\x28\x01\x29\x01\x26\x01\x32\x01\x2c\x01\x4e\x00\x13\x01\x14\x01\x1c\x01\x38\x01\x01\x01\x02\x01\x83\x00\x20\x01\x05\x01\x06\x01\x20\x01\x08\x01\x26\x01\x26\x01\x6e\x00\x88\x00\x26\x01\x24\x01\x25\x01\x00\x00\x27\x01\x79\x00\x7a\x00\x32\x01\x2b\x01\x34\x01\x35\x01\x18\x01\x0e\x01\x0f\x01\x10\x01\x6e\x00\x83\x00\x1e\x01\x1f\x01\x20\x01\x21\x01\x2e\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2e\x01\x1c\x01\x19\x00\x2e\x01\x36\x01\x88\x00\x36\x01\x36\x01\x95\x00\x2e\x01\x1c\x01\x26\x01\x36\x01\x72\x00\x36\x01\x26\x01\x36\x01\x76\x00\x4f\x00\x7a\x00\x26\x01\x52\x00\x2d\x00\x54\x00\x26\x01\x56\x00\x32\x01\x26\x01\x34\x01\x35\x01\x32\x01\x26\x01\x34\x01\x35\x01\x26\x01\x32\x01\x7c\x00\x34\x01\x35\x01\xad\x00\x32\x01\x4c\x00\x34\x01\x35\x01\x32\x01\x1c\x01\x34\x01\x35\x01\x32\x01\x54\x00\x34\x01\x35\x01\x0c\x01\x00\x00\x0e\x01\x26\x01\x10\x01\x0c\x01\x34\x00\x0e\x01\x4d\x00\x10\x01\x0c\x01\x20\x01\x0e\x01\x1d\x01\x10\x01\x4d\x00\x20\x01\x26\x01\x1e\x01\x1f\x01\x20\x01\x86\x00\x26\x01\x1e\x01\x1f\x01\x20\x01\x26\x01\x4e\x00\x1e\x01\x1f\x01\x20\x01\x26\x01\x1d\x01\x39\x00\x65\x00\x20\x01\x26\x01\x3d\x00\x3e\x00\x3f\x00\x40\x00\x26\x01\x42\x00\x03\x01\x04\x01\x05\x01\x06\x01\x00\x00\x4e\x00\x6f\x00\xa0\x00\xa1\x00\x6e\x00\x95\x00\x74\x00\xfe\x00\xff\x00\x7c\x00\x52\x00\x6e\x00\x03\x01\x1d\x01\x05\x01\x06\x01\x20\x01\x1d\x01\x5a\x00\x5b\x00\x20\x01\x8a\x00\x26\x01\x5f\x00\x20\x01\xa1\x00\x26\x01\x85\x00\x64\x00\x92\x00\x26\x01\x56\x00\x6e\x00\x29\x01\x97\x00\x98\x00\x99\x00\x9a\x00\x1d\x01\x1d\x01\x4e\x00\x20\x01\x20\x01\x58\x00\xb0\x00\xb1\x00\xb2\x00\x26\x01\x26\x01\x4b\x00\x29\x01\xfe\x00\xff\x00\x64\x00\x1d\x01\x7f\x00\x03\x01\x20\x01\x05\x01\x06\x01\x4e\x00\x4f\x00\x6d\x00\x26\x01\x01\x01\x02\x01\xfe\x00\xff\x00\x05\x01\x06\x01\x73\x00\x03\x01\x32\x01\x05\x01\x06\x01\x66\x00\xc1\x00\x52\x00\x38\x01\x00\x00\x7d\x00\x9a\x00\x1d\x01\x6d\x00\x65\x00\x20\x01\xa0\x00\xa1\x00\xcd\x00\x11\x01\x12\x01\x26\x01\x4e\x00\xb6\x00\x29\x01\xa0\x00\xa1\x00\x1d\x01\x7d\x00\x64\x00\x20\x01\x6a\x00\x01\x00\x28\x01\x29\x01\x6e\x00\x26\x01\x7c\x00\x6d\x00\x29\x01\xa1\x00\xb7\x00\xb8\x00\xb9\x00\x41\x00\x85\x00\xa0\x00\xa1\x00\xbe\x00\x2f\x01\xc1\x00\xc1\x00\x15\x00\xc3\x00\x1a\x01\xc5\x00\x1c\x01\x4b\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcd\x00\xcd\x00\xce\x00\x39\x00\x26\x01\x66\x00\x13\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x71\x00\x42\x00\x6e\x00\x1a\x01\x00\x00\x1c\x01\x0a\x01\x0b\x01\x00\x00\x0d\x01\x0e\x01\x7c\x00\x10\x01\x11\x01\x12\x01\x26\x01\x4f\x00\x52\x00\x6d\x00\x52\x00\xa0\x00\xa1\x00\x1a\x01\x1b\x01\x1c\x01\x5a\x00\x5b\x00\xa0\x00\xa1\x00\x35\x00\x5f\x00\x32\x01\xf7\x00\xf8\x00\x26\x01\x64\x00\x64\x00\x38\x01\x0e\x01\x0f\x01\x10\x01\x19\x00\x01\x01\x02\x01\x8a\x00\x6d\x00\x05\x01\x06\x01\x2a\x01\x2b\x01\x0a\x01\x0b\x01\x92\x00\x2f\x01\x0e\x01\x19\x00\x10\x01\x97\x00\x98\x00\x99\x00\x9a\x00\x2d\x00\x7f\x00\x7b\x00\x7c\x00\x1a\x01\x1a\x01\x1c\x01\x1c\x01\x58\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1a\x01\x2d\x00\x1c\x01\x26\x01\x26\x01\x26\x01\x6a\x00\x28\x01\x29\x01\x4d\x00\x6e\x00\x2c\x01\x26\x01\x54\x00\x1a\x01\x66\x00\x1c\x01\x32\x01\x33\x01\x34\x01\x35\x01\x1a\x01\x73\x00\x1c\x01\x5f\x00\xc1\x00\x26\x01\x57\x00\xa0\x00\xa1\x00\x64\x00\x53\x00\x7d\x00\x26\x01\x64\x00\x1e\x00\x68\x00\xcd\x00\x54\x00\x6d\x00\x56\x00\x4b\x00\x6e\x00\x6d\x00\xb7\x00\xb8\x00\xb9\x00\x39\x00\x74\x00\x62\x00\x2d\x00\xbe\x00\xaa\x00\x1a\x00\xc1\x00\x0e\x01\xc3\x00\x10\x01\xc5\x00\x4b\x00\x6d\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x62\x00\xcd\x00\xce\x00\x1a\x01\x1c\x01\x1c\x01\x51\x00\x52\x00\x2e\x00\x2f\x00\x1a\x01\x6d\x00\x1c\x01\x8a\x00\x26\x01\x26\x01\x66\x00\x95\x00\x19\x00\x90\x00\x5f\x00\x92\x00\x26\x01\x86\x00\x6e\x00\x64\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x69\x00\x6a\x00\x84\x00\x0a\x01\x0b\x01\x07\x01\x0d\x01\x0e\x01\x2d\x00\x10\x01\x11\x01\x12\x01\x4f\x00\xf7\x00\xf8\x00\x52\x00\x68\x00\x13\x01\x14\x01\x1a\x01\x1b\x01\x1c\x01\x6e\x00\x01\x01\x02\x01\xfe\x00\xff\x00\x05\x01\x06\x01\x62\x00\x03\x01\x26\x01\x05\x01\x06\x01\x24\x01\x25\x01\x20\x01\x27\x01\xc1\x00\x61\x00\x6d\x00\x2b\x01\x26\x01\x1e\x00\x4d\x00\x29\x01\x03\x01\x04\x01\x05\x01\x06\x01\xcd\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1a\x01\x1d\x01\x1c\x01\x2d\x00\x20\x01\x26\x01\x57\x00\x28\x01\x29\x01\x5a\x00\x26\x01\x2c\x01\x26\x01\x29\x01\x5f\x00\x53\x00\x68\x00\x32\x01\x33\x01\x34\x01\x35\x01\x1e\x00\x6e\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x74\x00\x29\x01\xbe\x00\x95\x00\x78\x00\xc1\x00\x73\x00\xc3\x00\x2d\x00\xc5\x00\xf3\x00\xf4\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x03\x01\x04\x01\x05\x01\x06\x01\x51\x00\x52\x00\x1f\x00\x4e\x00\x4f\x00\x0a\x01\x0b\x01\x57\x00\x0d\x01\x0e\x01\x5a\x00\x10\x01\x11\x01\x12\x01\x5f\x00\x5f\x00\x62\x00\x2e\x00\x2f\x00\x64\x00\x68\x00\x1a\x01\x1b\x01\x1c\x01\x69\x00\x6a\x00\x6e\x00\x6d\x00\x08\x01\x55\x00\x1e\x01\x1f\x01\x20\x01\x26\x01\x29\x01\x73\x00\xf7\x00\xf8\x00\x26\x01\x77\x00\x1a\x01\x15\x01\x1c\x01\x17\x01\x18\x01\x7c\x00\x01\x01\x02\x01\x7c\x00\x14\x00\x05\x01\x06\x01\x26\x01\x21\x01\x67\x00\x23\x01\x24\x01\x25\x01\x20\x01\x27\x01\x66\x00\x7d\x00\x2a\x01\x2b\x01\x26\x01\x72\x00\x28\x01\x29\x01\x6e\x00\x76\x00\xa8\x00\xa9\x00\xaa\x00\x67\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x31\x00\x32\x00\xa8\x00\xa9\x00\xaa\x00\x26\x01\x72\x00\x28\x01\x29\x01\x68\x00\x76\x00\x2c\x01\xf2\x00\xf3\x00\xf4\x00\x6e\x00\x95\x00\x32\x01\x33\x01\x34\x01\x35\x01\x1a\x01\x4d\x00\x1c\x01\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x3f\x00\x40\x00\xbe\x00\x57\x00\x26\x01\xc1\x00\x5a\x00\xc3\x00\x54\x00\xc5\x00\x62\x00\x5f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x5f\x00\x68\x00\x6d\x00\xa8\x00\xa9\x00\xaa\x00\x67\x00\x6e\x00\x1e\x01\x1f\x01\x20\x01\x62\x00\x73\x00\x74\x00\x68\x00\x4f\x00\x26\x01\x72\x00\x5f\x00\x53\x00\x6e\x00\x76\x00\x6d\x00\x64\x00\xfc\x00\xfd\x00\x65\x00\xff\x00\x67\x00\x6e\x00\x69\x00\x03\x01\x6d\x00\x05\x01\x06\x01\x03\x01\x04\x01\x05\x01\x06\x01\x72\x00\xf7\x00\xf8\x00\x52\x00\x76\x00\x54\x00\x03\x01\x04\x01\x05\x01\x06\x01\x1d\x01\x01\x01\x02\x01\x20\x01\x67\x00\x05\x01\x06\x01\x32\x01\x1d\x01\x26\x01\x65\x00\x20\x01\x67\x00\x38\x01\x69\x00\x72\x00\x30\x00\x26\x01\x6d\x00\x76\x00\x29\x01\x2d\x00\x2e\x00\x72\x00\x29\x01\x4c\x00\x4d\x00\x3b\x00\x3c\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x32\x01\x29\x01\xa3\x00\xa4\x00\xa5\x00\x26\x01\x38\x01\x28\x01\x29\x01\x85\x00\x32\x01\x2c\x01\x03\x01\x04\x01\x05\x01\x06\x01\x38\x01\x32\x01\x33\x01\x34\x01\x35\x01\x54\x00\x4d\x00\x56\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x54\x00\x1d\x01\xbe\x00\x57\x00\x20\x01\xc1\x00\x5a\x00\xc3\x00\x6e\x00\xc5\x00\x26\x01\x5f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x14\x00\x65\x00\x29\x01\x65\x00\x62\x00\x67\x00\x8a\x00\x69\x00\x6f\x00\x4e\x00\x4f\x00\x32\x01\x73\x00\x74\x00\x92\x00\x6d\x00\x72\x00\x38\x01\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x64\x00\x4d\x00\x85\x00\x4d\x00\x87\x00\x88\x00\x31\x00\x32\x00\x33\x00\x6d\x00\x54\x00\x57\x00\x95\x00\x57\x00\x5a\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\x5f\x00\x23\x00\x5f\x00\x24\x01\x25\x01\x9a\x00\x27\x01\x62\x00\x01\x01\x02\x01\x2b\x01\x68\x00\x05\x01\x06\x01\x2f\x01\x67\x00\x6f\x00\x6e\x00\x6d\x00\xc1\x00\x73\x00\x74\x00\x73\x00\x74\x00\x77\x00\x78\x00\x77\x00\x78\x00\x73\x00\x62\x00\x75\x00\xcd\x00\x03\x01\x04\x01\x05\x01\x06\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x6d\x00\x1e\x01\x1f\x01\x20\x01\xc1\x00\x26\x01\x8d\x00\x28\x01\x29\x01\x26\x01\x7c\x00\x2c\x01\x03\x01\x04\x01\x05\x01\x06\x01\xcd\x00\x32\x01\x33\x01\x34\x01\x35\x01\x1e\x01\x1f\x01\x20\x01\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x26\x01\x29\x01\xbe\x00\x0b\x01\x20\x01\xc1\x00\x0e\x01\xc3\x00\x10\x01\xc5\x00\x26\x01\x3a\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x20\x01\x4e\x00\x29\x01\x95\x00\x0a\x01\x0b\x01\x26\x01\x0d\x01\x0e\x01\x32\x01\x10\x01\x11\x01\x12\x01\x35\x00\x0b\x01\x38\x01\x95\x00\x0e\x01\x5f\x00\x10\x01\x1a\x01\x1b\x01\x1c\x01\x64\x00\x65\x00\x66\x00\x4d\x00\x6a\x00\x95\x00\x0a\x01\x0b\x01\x6e\x00\x26\x01\x0e\x01\x13\x00\x10\x01\x57\x00\x6d\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\x6a\x00\x62\x00\x5f\x00\x1a\x01\x6e\x00\x1c\x01\x6a\x00\x1f\x00\x01\x01\x02\x01\x6e\x00\x4d\x00\x05\x01\x06\x01\x4b\x00\x26\x01\x72\x00\x1e\x01\x1f\x01\x20\x01\x76\x00\x57\x00\x73\x00\x74\x00\x5a\x00\x26\x01\x77\x00\x78\x00\x2b\x01\x5f\x00\x72\x00\x33\x01\x2f\x01\x1f\x01\x20\x01\x37\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x26\x01\x0b\x01\x28\x01\x29\x01\x0e\x01\x26\x01\x10\x01\x28\x01\x29\x01\x73\x00\x74\x00\x2c\x01\x33\x01\x77\x00\x78\x00\x6e\x00\x37\x01\x32\x01\x33\x01\x34\x01\x35\x01\x65\x00\x4d\x00\x4e\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x58\x00\x4e\x00\xbe\x00\x57\x00\x33\x01\xc1\x00\x5a\x00\xc3\x00\x37\x01\xc5\x00\x4f\x00\x5f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x54\x00\x4e\x00\x65\x00\x61\x00\x67\x00\x63\x00\x69\x00\x4b\x00\x6f\x00\xbb\x00\xbc\x00\xbd\x00\x73\x00\x74\x00\x11\x00\x72\x00\x77\x00\x78\x00\x5f\x00\x76\x00\x5c\x00\x5d\x00\x5e\x00\x64\x00\x65\x00\x66\x00\x24\x01\x25\x01\x00\x01\x27\x01\x02\x01\x8a\x00\x61\x00\x05\x01\x63\x00\x4b\x00\x08\x01\x90\x00\x4b\x00\x92\x00\xf7\x00\xf8\x00\x3f\x00\x40\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x14\x01\x4b\x00\x01\x01\x02\x01\xff\x00\x52\x00\x05\x01\x06\x01\x03\x01\x1d\x01\x05\x01\x06\x01\x20\x01\xb3\x00\xb4\x00\xb5\x00\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x4e\x00\x4f\x00\x4c\x00\x4d\x00\x02\x00\x03\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1d\x01\x02\x00\x03\x00\x20\x01\xc1\x00\x26\x01\x45\x00\x28\x01\x29\x01\x26\x01\x56\x00\x2c\x01\x29\x01\x1e\x01\x1f\x01\x20\x01\xcd\x00\x32\x01\x33\x01\x34\x01\x35\x01\x26\x01\x4d\x00\x7c\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x54\x00\x54\x00\xbe\x00\x57\x00\x68\x00\xc1\x00\x5a\x00\xc3\x00\x61\x00\xc5\x00\x63\x00\x5f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x61\x00\x68\x00\x63\x00\x68\x00\x51\x00\x52\x00\x8a\x00\x6e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x73\x00\x74\x00\x92\x00\x68\x00\x77\x00\x78\x00\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x64\x00\xb3\x00\xb4\x00\xb5\x00\x4e\x00\x69\x00\x0a\x01\x0b\x01\x68\x00\x0d\x01\x0e\x01\x68\x00\x10\x01\x11\x01\x12\x01\x6e\x00\x6f\x00\xf7\x00\xf8\x00\xb3\x00\xb4\x00\xb5\x00\x1a\x01\x1b\x01\x1c\x01\xbf\x00\xc0\x00\x01\x01\x02\x01\x6e\x00\x6f\x00\x05\x01\x06\x01\x6e\x00\x26\x01\xe3\x00\xe4\x00\xe5\x00\xc1\x00\xe7\x00\xbf\x00\xc0\x00\x09\x01\x0a\x01\x0b\x01\x52\x00\x61\x00\x0e\x01\x63\x00\x10\x01\xcd\x00\xbf\x00\xc0\x00\x1f\x01\x20\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x1a\x01\x26\x01\x1c\x01\x28\x01\x29\x01\x26\x01\x4b\x00\x28\x01\x29\x01\x71\x00\x72\x00\x2c\x01\x26\x01\x1e\x01\x1f\x01\x20\x01\x6e\x00\x32\x01\x33\x01\x34\x01\x35\x01\x26\x01\x6e\x00\x6f\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x0d\x00\x61\x00\xbe\x00\x63\x00\x61\x00\xc1\x00\x63\x00\xc3\x00\x61\x00\xc5\x00\x63\x00\x66\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x61\x00\x4e\x00\x63\x00\x8f\x00\x0a\x01\x0b\x01\x6a\x00\x0d\x01\x0e\x01\x8d\x00\x10\x01\x11\x01\x12\x01\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5f\x00\x9a\x00\x1a\x01\x1b\x01\x1c\x01\x64\x00\x65\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\x61\x00\xff\x00\x63\x00\x26\x01\x00\x01\x03\x01\x02\x01\x05\x01\x06\x01\x05\x01\x8d\x00\xf7\x00\xf8\x00\xb3\x00\xb4\x00\xb5\x00\x23\x01\x24\x01\x25\x01\x8d\x00\x27\x01\x01\x01\x02\x01\x2a\x01\x2b\x01\x05\x01\x06\x01\x68\x00\x2f\x01\xc1\x00\x61\x00\x1d\x01\x63\x00\x1d\x01\x20\x01\x6e\x00\x20\x01\xb3\x00\xb4\x00\xb5\x00\x26\x01\xcd\x00\x26\x01\x29\x01\x28\x01\x29\x01\xb3\x00\xb4\x00\xb5\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x23\x01\x24\x01\x25\x01\x66\x00\x27\x01\x26\x01\x7d\x00\x28\x01\x29\x01\x30\x01\x31\x01\x2c\x01\x23\x01\x24\x01\x25\x01\x54\x00\x27\x01\x32\x01\x33\x01\x34\x01\x35\x01\x61\x00\x4b\x00\x63\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x4b\x00\x61\x00\xbe\x00\x63\x00\x61\x00\xc1\x00\x63\x00\xc3\x00\x61\x00\xc5\x00\x63\x00\x4b\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x0d\x00\x0a\x01\x0b\x01\x6d\x00\x61\x00\x0e\x01\x63\x00\x10\x01\x09\x01\x0a\x01\x0b\x01\x52\x00\xe5\x00\x0e\x01\xe7\x00\x10\x01\x15\x00\x1a\x01\x5f\x00\x1c\x01\x45\x00\x46\x00\x6f\x00\x64\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\x26\x01\xff\x00\x6f\x00\x6d\x00\x6f\x00\x03\x01\x68\x00\x05\x01\x06\x01\x11\x01\x12\x01\xf7\x00\xf8\x00\xf6\x00\xf7\x00\x68\x00\xa4\x00\xa5\x00\x36\x00\x37\x00\x68\x00\x01\x01\x02\x01\x6f\x00\x6a\x00\x05\x01\x06\x01\x6a\x00\x68\x00\x68\x00\x62\x00\x1d\x01\x6d\x00\x0c\x00\x20\x01\x34\x00\x19\x00\x57\x00\x4e\x00\x6e\x00\x26\x01\x6f\x00\x68\x00\x29\x01\x6e\x00\x68\x00\x4d\x00\x68\x00\x68\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x68\x00\x62\x00\x68\x00\x68\x00\x68\x00\x26\x01\x66\x00\x28\x01\x29\x01\x54\x00\x4f\x00\x2c\x01\x6e\x00\x17\x00\x4d\x00\x52\x00\x6e\x00\x32\x01\x33\x01\x34\x01\x35\x01\x62\x00\x6e\x00\x54\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x6e\x00\x68\x00\xbe\x00\x6e\x00\x56\x00\xc1\x00\x4e\x00\xc3\x00\x4b\x00\xc5\x00\x4f\x00\x4b\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\x4e\x00\xff\x00\x8a\x00\x66\x00\x4e\x00\x03\x01\x4b\x00\x05\x01\x06\x01\x7d\x00\x92\x00\x68\x00\x4b\x00\x68\x00\x5f\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x64\x00\x56\x00\x52\x00\xfe\x00\xff\x00\x4e\x00\x6f\x00\x6f\x00\x03\x01\x6d\x00\x05\x01\x06\x01\x1d\x01\x19\x00\x6e\x00\x20\x01\x4e\x00\xf7\x00\xf8\x00\x24\x01\x25\x01\x26\x01\x27\x01\x19\x00\x29\x01\x68\x00\x2b\x01\x01\x01\x02\x01\x4f\x00\x2f\x01\x05\x01\x06\x01\x1a\x00\x1d\x01\x7c\x00\x72\x00\x20\x01\xc1\x00\x4b\x00\x7c\x00\x4b\x00\x16\x00\x26\x01\x0c\x00\x6d\x00\x29\x01\x67\x00\x7c\x00\x4b\x00\xcd\x00\x66\x00\x19\x00\x62\x00\x6f\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x4e\x00\x4e\x00\x6e\x00\x4e\x00\x4e\x00\x26\x01\x4e\x00\x28\x01\x29\x01\x5f\x00\x6e\x00\x2c\x01\x52\x00\x4f\x00\x19\x00\x54\x00\x19\x00\x32\x01\x33\x01\x34\x01\x35\x01\x07\x00\x4f\x00\x56\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x39\x00\x4b\x00\x79\x00\xbe\x00\x52\x00\x54\x00\xc1\x00\x66\x00\xc3\x00\x7d\x00\xc5\x00\x52\x00\x62\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x68\x00\x6d\x00\x6d\x00\x86\x00\x0a\x01\x0b\x01\x66\x00\x0d\x01\x0e\x01\x68\x00\x10\x01\x11\x01\x12\x01\x67\x00\x19\x00\x19\x00\x68\x00\x85\x00\x5f\x00\x57\x00\x1a\x01\x1b\x01\x1c\x01\x64\x00\x86\x00\x6d\x00\x19\x00\x52\x00\x2d\x00\x4d\x00\x4e\x00\x6d\x00\x26\x01\x4f\x00\x6e\x00\x4b\x00\x4b\x00\x5f\x00\x19\x00\x57\x00\xf7\x00\xf8\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x07\x00\x07\x00\x01\x01\x02\x01\x85\x00\x19\x00\x05\x01\x06\x01\x4e\x00\x5f\x00\x66\x00\x7c\x00\x19\x00\x4d\x00\x4b\x00\x6f\x00\x19\x00\x16\x00\x4b\x00\x73\x00\x74\x00\x54\x00\x4e\x00\x77\x00\x78\x00\x6d\x00\x1a\x00\x4f\x00\x11\x00\x33\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\x23\x00\x86\x00\x4d\x00\x07\x00\x1a\x00\x26\x01\x7d\x00\x28\x01\x29\x01\x09\x00\x68\x00\x2c\x01\x3a\x00\x4d\x00\x67\x00\x67\x00\x65\x00\x32\x01\x33\x01\x34\x01\x35\x01\x2e\x00\x52\x00\x56\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\x01\x01\x02\x01\x6e\x00\xbe\x00\x05\x01\x06\x01\xc1\x00\x4d\x00\xc3\x00\x68\x00\xc5\x00\x6d\x00\x8a\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\x92\x00\x4e\x00\x6d\x00\x45\x00\x68\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x1e\x01\x1f\x01\x20\x01\x62\x00\x02\x00\x62\x00\x8a\x00\x5f\x00\x26\x01\x62\x00\x28\x01\x29\x01\x4e\x00\x56\x00\x92\x00\x86\x00\x6e\x00\x5f\x00\x7d\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x68\x00\x02\x00\x6e\x00\x4b\x00\x68\x00\x68\x00\x52\x00\x68\x00\xf7\x00\xf8\x00\x67\x00\x52\x00\x67\x00\x19\x00\x68\x00\xc1\x00\x8a\x00\x07\x00\x01\x01\x02\x01\x85\x00\x4e\x00\x05\x01\x06\x01\x92\x00\x19\x00\x67\x00\xcd\x00\x73\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x4d\x00\x19\x00\x07\x00\x68\x00\x73\x00\xc1\x00\x30\x00\x2f\x01\xec\x00\xec\x00\xec\x00\x59\x00\xd1\x00\x1d\x01\x1e\x01\x1f\x01\x20\x01\xcd\x00\x38\x00\x43\x00\x80\x00\x31\x00\x26\x01\x2d\x01\x28\x01\x29\x01\x7d\x00\x10\x01\x2c\x01\x32\x00\x7d\x00\x81\x00\x81\x00\x2e\x01\x32\x01\x33\x01\x34\x01\x35\x01\xc1\x00\x59\x00\x2e\x01\xa2\x00\x85\x00\x74\x00\x2f\x01\xcf\x00\x8b\x00\x2e\x01\x16\x00\xdf\x00\xcd\x00\x2e\x01\x2d\x01\x16\x00\x30\x00\x0a\x01\x0b\x01\x03\x00\x0d\x01\x0e\x01\xe7\x00\x10\x01\x11\x01\x12\x01\x2d\x01\xdf\x00\x54\x00\x33\x01\x68\x00\x33\x01\xc6\x00\x1a\x01\x1b\x01\x1c\x01\x43\x00\x8a\x00\x2d\x01\x2d\x01\x0a\x01\x0b\x01\x2d\x01\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\x57\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x6c\x00\x55\x00\x1a\x01\x1b\x01\x1c\x01\x29\x01\x76\x00\x74\x00\x72\x00\x7e\x00\x34\x00\x16\x00\x16\x00\x2c\x00\x26\x01\x58\x00\x20\x00\x20\x00\x7d\x00\x0a\x01\x0b\x01\x7d\x00\x0d\x01\x0e\x01\x33\x00\x10\x01\x11\x01\x12\x01\x63\x00\x5e\x00\x47\x00\x6b\x00\x70\x00\x67\x00\x8b\x00\x1a\x01\x1b\x01\x1c\x01\xc1\x00\x8b\x00\xa7\x00\x2c\x00\x0e\x00\x2d\x01\xc6\x00\x20\x00\x8a\x00\x26\x01\x20\x00\x70\x00\xcd\x00\xe7\x00\x90\x00\xa7\x00\x92\x00\x4a\x00\x17\x00\xb5\x00\x17\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xa5\x00\x45\x00\x8a\x00\x34\x00\x2e\x01\x4b\x00\x2d\x01\x2d\x01\x90\x00\x50\x00\x92\x00\x50\x00\x4f\x00\xae\x00\x1c\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x1c\x00\x26\x00\x2d\x01\x0b\x00\x31\x00\x56\x00\x33\x01\x59\x00\x86\x00\x87\x00\x2e\x01\x2d\x01\x8a\x00\x2e\x01\x35\x00\x2d\x01\x8e\x00\x8f\x00\x90\x00\xc1\x00\x92\x00\x93\x00\x2e\x01\x54\x00\x2d\x01\x97\x00\x98\x00\x99\x00\x9a\x00\x0a\x01\x0b\x01\xcd\x00\x0d\x01\x0e\x01\x56\x00\x10\x01\x11\x01\x12\x01\xc1\x00\x16\x00\x2d\x01\x2d\x01\x16\x00\x2e\x01\x20\x00\x1a\x01\x1b\x01\x1c\x01\xa7\x00\x2e\x01\xcd\x00\x20\x00\x2e\x01\x2e\x01\x17\x00\xff\xff\x17\x00\x26\x01\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xf7\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x26\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xf7\x00\xff\xff\x93\x00\x32\x01\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\x26\x01\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\x32\x01\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x52\x00\xff\xff\xff\xff\x87\x00\xff\xff\x57\x00\x8a\x00\xff\xff\x5a\x00\xff\xff\xff\xff\x8f\x00\x90\x00\x5f\x00\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xf7\x00\xff\xff\xc1\x00\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\x57\x00\x0d\x01\x0e\x01\x5a\x00\x10\x01\x11\x01\x12\x01\xff\xff\x5f\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x6e\x00\xff\xff\xff\xff\x26\x01\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\x87\x00\xf7\x00\xff\xff\x8a\x00\x32\x01\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\x32\x01\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\x87\x00\xd0\x00\x26\x01\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\x32\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\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\x8a\x00\xff\xff\xff\xff\xff\xff\xf7\x00\x8f\x00\x90\x00\xf7\x00\xf8\x00\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x26\x01\xc1\x00\x28\x01\x29\x01\x8a\x00\xff\xff\x2c\x01\xff\xff\x08\x01\x32\x01\xff\xff\x91\x00\xff\xff\xcd\x00\x94\x00\x95\x00\x96\x00\xff\xff\xff\xff\x99\x00\x9a\x00\x15\x01\xff\xff\x17\x01\x18\x01\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x01\xff\xff\x23\x01\x24\x01\x25\x01\xff\xff\x27\x01\xff\xff\xaf\x00\x2a\x01\x2b\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x26\x01\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\x26\x01\x99\x00\x9a\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\x99\x00\x9a\x00\xff\xff\xaf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\x57\x00\xff\xff\xff\xff\x5a\x00\x26\x01\xff\xff\xc1\x00\x8a\x00\x5f\x00\xff\xff\xff\xff\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x93\x00\x33\x01\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x4d\x00\xff\xff\x4f\x00\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\x57\x00\x0d\x01\x0e\x01\x5a\x00\x10\x01\x11\x01\x12\x01\x26\x01\x5f\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\x33\x01\xff\xff\xcd\x00\xff\xff\x6f\x00\xff\xff\x26\x01\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xf7\x00\xff\xff\x8a\x00\xff\xff\x33\x01\xff\xff\x8e\x00\x8f\x00\x90\x00\xff\xff\x92\x00\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xcd\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x9c\x00\xff\xff\x32\x01\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\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xf7\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x9c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xcd\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x4d\x00\xff\xff\xff\xff\x57\x00\xff\xff\xc1\x00\x5a\x00\xff\xff\xff\xff\x26\x01\x57\x00\x5f\x00\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xcd\x00\x5f\x00\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xf7\x00\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\x6f\x00\x77\x00\x78\x00\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x0a\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xcd\x00\xff\xff\x93\x00\xff\xff\x16\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xc1\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x08\x01\xff\xff\x2c\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x21\x01\xff\xff\x23\x01\x24\x01\x25\x01\xff\xff\x27\x01\xff\xff\xff\xff\x2a\x01\x2b\x01\xcd\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x71\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x32\x01\xf7\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x32\x01\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\x8f\x00\x90\x00\xff\xff\xff\xff\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x0a\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xcd\x00\xff\xff\x93\x00\xff\xff\x16\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\xc1\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x08\x01\xff\xff\x2c\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x15\x01\xff\xff\x17\x01\x18\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x21\x01\xff\xff\x23\x01\x24\x01\x25\x01\xff\xff\x27\x01\xff\xff\xff\xff\x2a\x01\x2b\x01\xcd\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x54\x00\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x71\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x32\x01\xf7\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\x26\x01\x93\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xc1\x00\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\x9f\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xf7\x00\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x32\x01\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\xff\xff\xff\xff\x2a\x01\x2b\x01\xff\xff\xff\xff\xff\xff\x2f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x2f\x01\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\x2f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\x8a\x00\xcd\x00\x02\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\x0a\x00\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xc1\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xf7\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xcd\x00\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x2f\x01\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\x1a\x01\x1b\x01\x1c\x01\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xc1\x00\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xc1\x00\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x9d\x00\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x9d\x00\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x9f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\xa6\x00\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xa6\x00\x8a\x00\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\xa6\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\x26\x01\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\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\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xc1\x00\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xf7\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x26\x01\x0a\x01\x0b\x01\xc1\x00\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x92\x00\x10\x01\x11\x01\x12\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xcd\x00\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\x26\x01\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x92\x00\x10\x01\x11\x01\x12\x01\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\x26\x01\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xcd\x00\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\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\xc1\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\x97\x00\x98\x00\x99\x00\x9a\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xc1\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\x99\x00\x9a\x00\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xc1\x00\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\x26\x01\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\x26\x01\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1b\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x01\x0b\x01\xff\xff\x0d\x01\x0e\x01\xff\xff\x10\x01\x11\x01\x12\x01\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x1a\x01\x1b\x01\x1c\x01\x08\x00\xff\xff\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x40\x00\xff\xff\xff\xff\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x39\x00\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4a\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\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\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\x6d\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\x93\x00\x94\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\x01\x00\x02\x00\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\x0a\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\x01\x00\x02\x00\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\x0a\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x71\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\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\x36\x00\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\x01\x00\x02\x00\xff\xff\x89\x00\x8a\x00\x8b\x00\x8c\x00\xff\xff\x8e\x00\x0a\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x71\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\x7c\x00\x7d\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\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\x11\x00\xff\xff\x93\x00\x94\x00\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\x7c\x00\x7d\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\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\x01\x00\x02\x00\x7c\x00\x7d\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\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\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\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\x01\x00\x02\x00\x7c\x00\x7d\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\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\x01\x00\x02\x00\x7c\x00\x7d\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\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\x01\x00\x02\x00\x7c\x00\x7d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x86\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x77\x00\x78\x00\xff\xff\x01\x00\x02\x00\x7c\x00\x7d\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\x16\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x02\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\x0a\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\x36\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\x71\x00\x93\x00\x94\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x7c\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x02\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\x0a\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x16\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x7c\x00\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\xff\xff\x7c\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\x7c\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\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\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\x3a\x01\xff\xff\x2c\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x3a\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xff\xff\x2f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x39\x01\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xff\xff\x2f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x39\x01\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xff\xff\x2f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\x39\x01\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xff\xff\xff\xff\xff\xff\xd7\x00\xd8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xff\xff\xff\xff\xd6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\xff\xff\xff\xff\xd6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\x08\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\x16\x01\x17\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\x22\x01\x23\x01\xff\xff\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\x39\x01\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd9\x00\xda\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe0\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xda\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x2d\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xef\x00\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xed\x00\xff\xff\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xdd\x00\xde\x00\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe0\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xdd\x00\xde\x00\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe0\x00\xe1\x00\xe2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xe5\x00\xe6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf0\x00\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xdc\x00\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xe9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf1\x00\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xe2\x00\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc1\x00\xc2\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\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\x39\x01\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\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\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x39\x01\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x02\x00\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x6f\x00\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\x71\x00\x72\x00\x73\x00\x74\x00\xff\xff\x76\x00\x16\x00\x78\x00\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\x36\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\x36\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\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\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\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\x67\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x6e\x00\xff\xff\x02\x00\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\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\xff\xff\x2c\x00\xff\xff\xff\xff\x02\x00\x67\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\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\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\x36\x00\xff\xff\x65\x00\x02\x00\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\x4c\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\x02\x00\x67\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\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\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\x36\x00\x02\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\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\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\x75\x00\x76\x00\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\x36\x00\x02\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\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\x36\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\x76\x00\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\x36\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\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x4c\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\x02\x00\x67\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\x75\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\x36\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\xff\xff\xff\xff\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x65\x00\xff\xff\x67\x00\x68\x00\x69\x00\xff\xff\xff\xff\x0a\x00\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\x74\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\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\x36\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\x72\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\x72\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\x72\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\x72\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\x72\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\x65\x00\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\x72\x00\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\x36\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\x71\x00\x72\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\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\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\x53\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\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x6e\x00\xff\xff\x1a\x00\x71\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\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\x02\x00\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x0a\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\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\x36\x00\x0a\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\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\x36\x00\x0a\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x71\x00\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\x36\x00\xff\xff\xff\xff\xc1\x00\x67\x00\xc3\x00\xff\xff\xc5\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\x71\x00\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\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\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\x71\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xc1\x00\x2c\x01\xc3\x00\xff\xff\xc5\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\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\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\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\xea\x00\xeb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xea\x00\xeb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\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\xea\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xc9\x00\xca\x00\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\x01\xcb\x00\xff\xff\xcd\x00\xce\x00\xff\xff\xff\xff\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x01\x02\x01\xff\xff\xff\xff\x05\x01\x06\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\x1e\x01\x1f\x01\x20\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x01\xff\xff\x28\x01\x29\x01\xff\xff\xff\xff\x2c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#  happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\x6f\x00\x73\x05\x54\x03\x32\x05\x33\x05\x95\x04\x8d\x04\x75\x05\xc9\x00\x88\x04\x85\x04\x84\x04\x85\x04\x86\x04\x06\x01\x86\x04\x07\x01\xf4\x03\x18\x05\x2f\x05\x30\x05\x86\x04\x08\x01\x09\x01\x0a\x01\x2d\x00\x2e\x00\x5d\x05\x0b\x01\x07\x02\x08\x02\x09\x02\xe9\x02\x2f\x00\x77\x05\x30\x00\x80\x02\x78\x05\xa6\x04\x08\x02\x09\x02\xa5\x04\x08\x02\xc2\x03\x14\x05\xa6\x04\x08\x02\x09\x02\xa6\x04\x08\x02\x09\x02\xca\x00\x23\x03\x8a\x04\x8b\x04\x8c\x04\x8d\x04\x5a\x05\x8b\x04\x8c\x04\x8d\x04\xe6\x01\x7f\x05\x8b\x04\x8c\x04\x8d\x04\x27\x03\x28\x03\x70\x05\x71\x05\x8d\x04\x77\x02\x78\x02\x23\x05\x8d\x04\x77\x02\x78\x02\x19\x05\x8d\x04\x60\x04\x69\x04\x6a\x04\x81\x04\xe0\x01\xc1\xff\x05\x02\xc1\xff\x05\x02\xc1\xff\x44\x04\x55\x03\x1f\x04\x20\x04\x3c\x03\x3b\x04\x20\x04\x6f\x02\x54\x02\x7c\x05\x73\x01\x40\x00\x88\x04\x87\x03\x05\x02\xbc\xff\xf5\x03\x90\xfe\xc7\xfc\x4e\x03\x90\xfe\x57\x05\x53\x03\x41\x00\x92\xfe\x4f\x01\x5e\x05\x05\x02\x2a\x02\xc1\xff\x58\x03\xc7\xfc\x96\x04\xc1\xff\x88\x04\xa6\x02\xfb\x02\x97\x04\x98\x04\x27\x05\x28\x05\x29\x05\x2a\x05\x98\x04\x05\x02\xec\x04\x72\x05\x2a\x05\x98\x04\x7e\x03\x34\x00\x92\xfe\xcb\x00\x0e\x03\x0f\x03\x8d\x00\xf7\x02\xcc\x00\x2b\x02\x90\x00\x0e\x03\x0f\x03\x92\x00\x93\x00\x94\x00\x95\x00\x2e\x01\x96\x00\x97\x00\x4b\x03\x35\x00\xff\x00\xfc\x02\x33\x00\x00\x01\x0d\x01\xca\x02\x50\x01\x55\x02\x5d\x03\xb0\x01\xf2\x02\x2f\x01\x06\x01\x43\x00\x44\x00\xa7\x02\xff\x00\x46\x00\x21\x03\x47\x00\x68\x05\xf8\x02\x34\x00\x71\x01\xbc\xff\x06\x02\x70\x02\x06\x02\x71\x02\x4a\x00\x00\x01\x4c\x00\x70\x02\x61\x04\xe8\x04\x20\x04\x07\x02\x3f\x04\x9c\x00\x9d\x00\x34\x00\x4d\x00\x34\x00\x06\x02\x34\x00\x58\x05\xf3\x02\x3d\x03\x9e\x00\x71\x00\x37\x00\xe1\x01\x72\x00\x73\x00\xe1\x01\x3c\xfe\x06\x02\xe2\x01\x69\x05\x5e\x03\x6b\x04\x29\x03\x7a\x02\xea\x02\x18\x01\xe1\x01\x79\x02\x9f\x03\x3c\x02\x11\x00\x11\x00\x56\x03\x27\x01\x06\x02\x23\x02\x4c\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\xe1\x01\x81\x02\xf5\x02\xea\x02\x75\x03\x11\x00\x56\x03\x7b\x00\x7c\x00\x11\x00\xe1\x01\xa0\x00\xff\x00\x82\x02\x83\x02\x50\x05\x56\x03\x70\x00\x71\x00\x2e\x03\x21\x04\x72\x00\x73\x00\x21\x04\x74\x00\x4d\x00\x11\x00\xf6\x02\x8f\x02\x11\x00\xcc\x01\x79\x00\x80\x00\x7a\x00\x1d\x01\x1e\x01\x8e\x04\x84\x02\x8f\x04\x90\x04\x75\x00\x62\x04\x63\x04\x47\x00\xfa\x01\x19\x04\x0e\x00\x0f\x00\x10\x00\x76\x00\x31\x05\x77\x00\x78\x00\x79\x00\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x34\x05\x45\x04\xc7\xfc\x34\x05\x31\x00\x19\x02\x31\x00\x31\x00\xe8\x02\x31\x05\x45\x04\x4d\x00\x31\x00\x8a\x00\x31\x00\x0a\x02\x31\x00\x25\x02\xfb\x01\x15\x03\x4d\x00\x0f\x01\xe6\x02\x26\x02\x0a\x02\xff\x00\x8e\x04\x0a\x02\x8f\x04\x90\x04\x8e\x04\x0a\x02\x8f\x04\x90\x04\x0a\x02\x8e\x04\x17\x03\x8f\x04\x90\x04\x61\x05\x8e\x04\x0e\x01\x8f\x04\x90\x04\x8e\x04\xed\x04\x8f\x04\x90\x04\x8e\x04\x34\x00\x8f\x04\x90\x04\x99\x04\x05\x02\x9a\x04\x4d\x00\x47\x00\x99\x04\x84\x02\x9a\x04\xd9\x02\x47\x00\x99\x04\x21\x04\x9a\x04\x22\x03\x47\x00\xde\x02\x18\x01\x11\x00\x9b\x04\x0f\x00\x10\x00\xff\xff\x11\x00\x9b\x04\x0f\x00\x10\x00\x11\x00\x05\x02\x9b\x04\x0f\x00\x10\x00\x11\x00\x22\x03\xc9\x00\x26\x04\x18\x01\x11\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\x11\x00\xe2\x00\x28\x01\x29\x01\x72\x00\x16\x01\x1f\x02\x22\x02\xdf\x02\xe9\x01\xea\x01\x05\x02\xff\xff\x23\x02\x1f\x01\x20\x01\x20\x02\xe3\x00\x27\x04\x15\x01\x29\x03\x72\x00\x16\x01\x18\x01\x1a\x02\xe4\x00\xe5\x00\x18\x01\x37\x00\x11\x00\xe6\x00\x2a\x01\x10\x04\x11\x00\x05\x02\xca\x00\xda\x02\x11\x00\xa2\x02\xdd\x03\x19\x01\x31\x01\x3d\x00\x3e\x00\x3f\x00\x17\x01\x29\x03\xf5\x01\x18\x01\x18\x01\x05\x02\xde\x01\xdf\x01\xe0\x01\x11\x00\x11\x00\xff\xff\x19\x01\x1f\x01\x20\x01\x06\x02\x1a\x02\xe7\x00\x15\x01\x18\x01\x72\x00\x16\x01\xa3\x02\x05\x02\xde\x03\x11\x00\x73\x03\x58\xff\x23\x01\x20\x01\xb5\x03\xa2\x02\xa4\x02\x15\x01\xe1\x01\x72\x00\x16\x01\xf2\x01\x40\x00\x60\x01\x6b\x04\x06\x02\x95\x01\xe5\x01\x17\x01\x69\x02\x63\x01\x18\x01\x15\x02\xea\x01\x41\x00\x6a\x02\xcf\x04\x11\x00\x0f\x02\xbc\x04\x19\x01\x7a\x03\xea\x01\x17\x01\xa3\x02\x58\xff\x18\x01\xb7\x02\x7a\x03\x79\x03\x06\x02\x07\x02\x11\x00\x63\x01\x1d\x03\x19\x01\x42\x05\xe8\x00\xe9\x00\xea\x00\x2f\x01\xc5\x04\x4f\x03\xea\x01\xeb\x00\x6b\x02\x40\x00\x8d\x00\xf1\x01\xec\x00\xeb\x01\x90\x00\x4c\x00\x06\x02\x92\x00\x93\x00\x94\x00\x95\x00\x41\x00\x96\x00\x97\x00\xc9\x00\x4d\x00\x7a\x03\xa5\x04\x82\x03\xdf\x00\xe0\x00\xe1\x00\x06\x02\xe2\x00\xa9\x04\xeb\x01\xf8\x01\x4c\x00\x43\x00\x44\x00\xdf\x03\x45\x00\x46\x00\x75\x03\x47\x00\x48\x00\x49\x00\x4d\x00\xb9\x02\xe3\x00\x06\x02\xf7\x01\x33\x03\xea\x01\x4a\x00\x4b\x00\x4c\x00\xe4\x00\xe5\x00\xf2\x03\xea\x01\x4e\x05\xe6\x00\xe1\x01\x9c\x00\x9d\x00\x4d\x00\xca\x00\xaa\x04\xe2\x01\x62\x04\x63\x04\x47\x00\x0d\x01\x9e\x00\x71\x00\x37\x00\x81\x00\x72\x00\x73\x00\x82\x00\x6d\x05\x43\x00\x44\x00\x30\x01\x83\x00\x46\x00\x6e\x05\x47\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x0e\x01\xe7\x00\x21\x01\x22\x01\xeb\x01\x4a\x00\x4c\x00\x4c\x00\x80\x00\xcd\x00\x9f\x00\x0f\x00\xce\x00\xeb\x01\x89\x00\x4c\x00\x4d\x00\x4d\x00\x11\x00\xed\x02\x7b\x00\x7c\x00\xfd\x01\xee\x02\xa0\x00\x4d\x00\xfe\x01\xeb\x01\xb0\x01\x4c\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xeb\x01\xe4\x04\x4c\x00\x62\x01\x40\x00\x4d\x00\x43\x01\x06\x05\xea\x01\x63\x01\xa6\x03\xf0\x01\x4d\x00\x92\xfe\xe3\x04\x8a\x00\x41\x00\xca\x03\x4a\x02\x8d\x00\xee\x01\x0e\x01\x60\x01\xe8\x00\xe9\x00\xea\x00\xc9\x00\xe9\x01\x7e\x02\x49\x00\xeb\x00\x41\x05\x7e\x02\x8d\x00\x0e\x01\xec\x00\x63\x01\x90\x00\xf6\x01\xe8\x01\x92\x00\x93\x00\x94\x00\x95\x00\xa2\x01\x96\x00\x97\x00\xeb\x01\x73\x02\x4c\x00\x48\x04\x49\x04\x63\x01\xf7\x01\xeb\x01\xa3\x01\x4c\x00\x37\x00\xd9\x01\x4d\x00\x4b\x02\x0f\x00\x10\x00\x44\x01\xe6\x00\x45\x01\x4d\x00\x25\x05\x11\x00\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x4a\x04\x4f\x04\x46\x01\x43\x00\x32\x01\x3e\x01\x45\x00\x46\x00\xf7\x01\x47\x00\x48\x00\x49\x00\xe1\x01\x9c\x00\x9d\x00\xd0\x01\xff\xff\x47\x00\x1c\x02\x4a\x00\x4b\x00\x4c\x00\x05\x03\x9e\x00\x71\x00\x23\x01\x20\x01\x72\x00\x73\x00\xd1\x01\x15\x01\x4d\x00\x72\x00\x16\x01\x3f\x01\x40\x01\x41\x01\x9a\x01\x40\x00\x4d\x00\x3f\x02\x65\x04\x06\x03\x07\x03\x23\x02\x9e\x03\x64\x01\xc0\x04\x72\x00\x16\x01\x41\x00\xcd\x00\x9f\x00\x0f\x00\xce\x00\xeb\x01\x17\x01\x4c\x00\x9f\x03\x18\x01\x11\x00\xff\x01\x7b\x00\x7c\x00\x89\xfd\x11\x00\xa0\x00\x4d\x00\x19\x01\xb6\x01\x66\x04\x67\x04\xed\x00\xee\x00\xef\x00\xf0\x00\x00\x02\x01\x02\xe8\x00\xe9\x00\x91\x02\x4c\x04\xc9\x00\x26\x03\x19\x01\xeb\x00\xb5\x01\x84\x00\x8d\x00\x11\x00\x93\x02\x2c\x01\x90\x00\x86\x00\xd8\x02\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x88\x00\x80\x00\x3a\x04\x64\x00\x48\x04\x49\x04\x24\x05\x67\x00\x11\x00\x43\x00\x44\x00\x18\x02\x45\x00\x46\x00\xff\xff\x47\x00\x48\x00\x49\x00\xe6\x00\xb4\x01\x74\x03\xf7\x01\x19\x02\xca\x00\x68\x04\x4a\x00\x4b\x00\x4c\x00\x4a\x04\x4b\x04\x62\x01\xa4\x01\x47\x01\x75\x03\x28\x04\x64\x00\x63\x01\x4d\x00\x68\x04\x67\x00\x9c\x00\x9d\x00\x8a\x00\x72\x03\x29\x04\x48\x01\xe1\x01\x49\x01\x4a\x01\x64\x00\x9e\x00\x71\x00\xb6\x04\x67\x00\x72\x00\x73\x00\x73\x03\x76\x00\xce\x04\x77\x00\x78\x00\x79\x00\xd8\x02\x7a\x00\x1d\x05\x71\x00\x7d\x00\x7e\x00\x72\x00\x73\x00\xc4\x04\xcf\x04\x6a\x05\x64\x00\xc2\x04\xbe\x04\xbf\x04\x67\x00\xcd\x00\x9f\x00\x0f\x00\xce\x00\x6b\x05\xc5\x04\xbd\x04\xbe\x04\xbf\x04\x11\x00\x17\x04\x7b\x00\x7c\x00\x18\x01\xa4\x04\xa0\x00\x48\x02\x49\x02\x4a\x02\x11\x00\xea\x04\xed\x00\xee\x00\xef\x00\xf0\x00\x7b\x00\x7c\x00\xa5\x04\xe8\x00\xe9\x00\x91\x02\x4c\x04\xc9\x00\x75\x03\xff\x00\xeb\x00\x01\x01\x02\x01\x8d\x00\x4d\x05\x93\x02\x14\x02\x90\x00\x4c\x00\xa1\x01\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x4e\x05\x4d\x00\x27\x02\x3f\x05\xbe\x04\xbf\x04\x23\x02\x7c\x01\x4b\x02\x0f\x00\x10\x00\x64\x01\x29\x01\x72\x00\x16\x01\x79\x01\x11\x00\x07\x04\xe6\x00\x4c\x00\xff\xff\x80\x00\x7a\x01\xca\x00\x2d\x02\x64\x01\x65\x01\x72\x00\x16\x01\x4d\x00\x11\x00\x81\x00\x9a\x02\x25\x03\x82\x00\x64\x01\xc0\x04\x72\x00\x16\x01\x83\x00\x9c\x00\x9d\x00\xc5\x02\xc6\x02\xc7\x02\x64\x01\xc0\x04\x72\x00\x16\x01\x19\x01\x9e\x00\x71\x00\xfd\x01\x14\xfd\x72\x00\x73\x00\xfe\x01\x4d\x01\x37\x03\x38\x03\x09\x03\x89\x00\x8a\x00\x19\x01\x71\x01\x8c\x00\x8d\x00\x64\x01\x63\x03\x72\x00\x16\x01\x0a\x03\x0b\x03\x19\x01\xf1\x04\xef\x04\x0e\x03\x0f\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\xe1\x01\x19\x01\x43\x03\x44\x03\x45\x03\x11\x00\xc1\x04\x7b\x00\x7c\x00\xff\xff\xe1\x01\xa0\x00\x64\x01\xc0\x04\x72\x00\x16\x01\xc1\x04\xed\x00\xee\x00\xef\x00\xf0\x00\x79\x04\x7a\x04\x19\x01\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\x2f\x02\x79\x00\xeb\x00\x7a\x00\x80\x01\x8d\x00\x43\x01\x93\x02\x81\x01\x90\x00\x82\x01\x42\x01\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x64\x00\x2d\x02\x19\x01\xb0\x01\x67\x00\xd7\x03\x37\x00\x11\x00\xa8\x02\xbf\x01\x7c\x00\xe1\x01\xc3\x01\xc9\x02\xda\x02\x27\x01\xca\x02\xc1\x04\xe6\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\xca\x00\x66\x01\x67\x01\x68\x01\x69\x01\x6a\x01\xc5\x03\x6b\x01\xff\xff\x90\x02\xc6\x03\x15\x01\x80\x00\x72\x00\x16\x01\x9b\x02\x98\x02\x99\x02\x9d\x00\xc1\x01\x95\x01\x79\x00\x81\x00\x7a\x00\xe3\x01\x82\x00\x14\x01\x9e\x00\x71\x00\x14\x01\x83\x00\x72\x00\x73\x00\x15\x01\x12\x01\x72\x00\x16\x01\x17\x01\x40\x00\xe7\x03\x18\x01\x62\x01\x18\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x63\x01\x11\x00\x19\x01\x41\x00\x11\x00\x89\x00\x8a\x00\xff\xff\xcd\x00\x9f\x00\x0f\x00\xce\x00\x17\x01\xc2\x01\x7e\x00\x18\x01\x40\x00\x11\x00\xc3\x01\x7b\x00\x7c\x00\x11\x00\xff\xff\xa0\x00\x19\x01\x6d\x01\x0f\x00\x10\x00\x41\x00\xed\x00\xee\x00\xef\x00\xf0\x00\x11\x00\xfc\x04\xfd\x04\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\x98\xfe\xd6\x02\xeb\x00\x98\xfe\x46\x00\x8d\x00\x47\x00\x93\x02\xa7\x01\x90\x00\xa8\x01\x09\x03\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x03\x02\x52\x04\xc5\x03\x11\x01\x43\x00\x44\x00\x82\x04\x45\x00\x46\x00\xc5\x03\x47\x00\x48\x00\x49\x00\x3d\x05\x2f\x03\xfc\x04\x48\x05\x46\x00\xe6\x00\x47\x00\x4a\x00\x4b\x00\x4c\x00\xca\x00\x53\x04\x59\x04\x56\x00\xf5\x01\xf3\x01\x43\x00\x44\x00\x02\x03\x4d\x00\x46\x00\x81\x00\x47\x00\x57\x00\x82\x00\x97\x02\x98\x02\x99\x02\x9d\x00\x83\x00\x1f\x05\x5b\x00\x4a\x00\x46\x00\x4c\x00\x47\x00\x00\x03\x9e\x00\x71\x00\x74\x01\xaa\x01\x72\x00\x73\x00\xc6\x01\x4d\x00\xc7\x01\xf2\x01\xf3\x01\xc8\x01\x2f\x02\x79\x00\x89\x00\x7a\x00\x65\x00\x66\x00\x8c\x00\xa8\x02\x68\x00\x69\x00\x64\x00\xc3\x01\xa4\x02\x0f\x00\x10\x00\xf9\x02\xcd\x00\x9f\x00\x0f\x00\xce\x00\x11\x00\xf1\x02\x77\x01\xcb\x01\x78\x01\x11\x00\x18\x01\x7b\x00\x7c\x00\x74\x01\x75\x01\xa0\x00\x11\x00\xe9\x02\x7b\x00\x7c\x00\xdd\x02\xed\x00\xee\x00\xef\x00\xf0\x00\x38\x03\x39\x03\x3a\x03\xe8\x00\xe9\x00\x91\x02\x55\x04\xc9\x00\x58\x03\xa7\x01\xeb\x00\xa8\x01\x84\x00\x8d\x00\xf0\x01\x93\x02\x1f\x05\x90\x00\x86\x00\xd5\x02\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x88\x00\x52\x04\x80\x00\xd4\x02\x8b\x00\x9f\x02\x0f\x00\x10\x00\x87\x01\x86\x02\x88\x01\xd1\x02\x81\x00\x11\x00\xcd\x02\x82\x00\x80\x00\x77\x01\xe6\x00\x78\x01\x83\x00\x73\x01\x6f\x01\xca\x00\x53\x04\x54\x04\x81\x00\xd3\x02\x63\x02\x82\x00\x64\x02\x37\x00\xd2\x02\x0e\x04\x83\x00\x0f\x04\x81\x02\x59\x03\x87\x02\x5a\x03\x9c\x00\x9d\x00\x89\x00\x8a\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xe1\x03\x83\x02\x9e\x00\x71\x00\x4d\x01\xcb\x02\x72\x00\x73\x00\x89\x00\x8a\x00\x71\x01\x6f\x01\x8c\x00\x8d\x00\x9c\x02\x0f\x00\x10\x00\xcc\x01\x79\x00\x06\x04\x7a\x00\x07\x04\x11\x00\x77\x01\x84\x02\x78\x01\xee\x04\xef\x04\x3b\x01\x3c\x01\xcd\x00\x9f\x00\x0f\x00\xce\x00\x76\x02\xf8\x03\xf9\x03\xfa\x03\x40\x00\x11\x00\xba\x02\x7b\x00\x7c\x00\x6e\x01\x6f\x01\xa0\x00\x38\x01\x39\x01\x3a\x01\x3b\x01\x41\x00\xed\x00\xee\x00\xef\x00\xf0\x00\x6c\x04\xf9\x03\xfa\x03\xe8\x00\xe9\x00\x91\x02\x55\x04\xc9\x00\x50\x01\xc1\x03\xeb\x00\xc2\x03\x5e\x04\x8d\x00\x5f\x04\x93\x02\x3e\x04\x90\x00\x3f\x04\xb9\x02\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xbe\x01\x10\x00\x24\x01\x25\x01\x48\x04\x49\x04\x37\x00\x11\x00\xb6\x02\xbf\x01\x7c\x00\xd3\x03\xd4\x03\xd5\x03\xda\x02\xae\x01\x5f\x03\x60\x03\xe6\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\xca\x00\x56\x00\x5f\x04\xf9\x03\xfa\x03\xf5\x04\x43\x00\x44\x00\xdb\x01\x45\x00\x46\x00\x57\x00\x47\x00\x48\x00\x49\x00\x74\x01\x01\x04\x9c\x00\x9d\x00\x5b\x00\x50\x04\x45\x03\x4a\x00\x4b\x00\x4c\x00\x7e\x02\x49\x00\x9e\x00\x71\x00\x84\x00\x80\x02\x72\x00\x73\x00\x2c\x01\x4d\x00\x86\x00\x63\x01\x3e\x02\x40\x00\xc7\xfc\xb4\x02\x65\x00\x66\x00\x00\xfd\x88\x00\x68\x00\x69\x00\xc1\x01\x95\x01\x79\x00\x41\x00\x7a\x00\xaf\x02\x10\x00\x3d\x02\xcd\x00\x9f\x00\x0f\x00\xce\x00\x11\x00\xae\x02\xbf\x01\x7c\x00\xff\x00\x11\x00\xaf\x02\x7b\x00\x7c\x00\xeb\x03\xec\x03\xa0\x00\xe1\x02\xe2\x02\xe3\x02\xe4\x02\xe5\x02\xed\x00\xee\x00\xef\x00\xf0\x00\xb3\x04\xf9\x03\xfa\x03\xe8\x00\xe9\x00\x91\x02\x4c\x04\xc9\x00\xac\x02\xee\x02\xeb\x00\xef\x02\xe1\x04\x8d\x00\xe2\x04\x93\x02\xd5\x04\x90\x00\xd6\x04\xab\x02\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x94\x04\x52\x04\x95\x04\xaa\x02\x43\x00\x44\x00\x59\x02\x45\x00\x46\x00\xde\x01\x47\x00\x48\x00\x49\x00\x7d\x05\xf9\x03\xfa\x03\x54\x05\x55\x05\xe6\x00\x47\x02\x4a\x00\x4b\x00\x4c\x00\xca\x00\xfd\x04\x66\x03\x68\x01\x69\x01\x6a\x01\xe1\x04\x6b\x01\xe2\x04\x4d\x00\x50\x02\x15\x01\xae\x01\x72\x00\x16\x01\x7d\x02\x7c\x02\x9c\x00\x9d\x00\x7c\x01\x7d\x01\x44\x00\x77\x02\x6f\x02\x46\x00\x75\x02\x47\x00\x9e\x00\x71\x00\x6c\x02\x68\x02\x72\x00\x73\x00\x67\x02\x61\x02\x40\x00\x7e\x01\x17\x01\x4c\x00\x60\x02\x18\x01\x82\x05\xf9\x03\xfa\x03\x5f\x02\x5a\x02\x11\x00\x41\x00\x4d\x00\x19\x01\x5e\x02\x59\x02\x58\x02\xb0\x01\x50\x02\xcd\x00\x9f\x00\x0f\x00\xce\x00\x41\x02\x40\x02\x3e\x02\x3d\x02\x3b\x02\x11\x00\x2d\x02\x7b\x00\x7c\x00\x29\x02\x24\x02\xa0\x00\x2c\x02\x21\x02\x28\x02\x1e\x02\x06\x01\xed\x00\xee\x00\xef\x00\xf0\x00\xf5\x01\xb9\x03\xb8\x03\xe8\x00\xe9\x00\x91\x02\x55\x04\xc9\x00\x03\x02\xb7\x03\xeb\x00\xb4\x03\xad\x03\x8d\x00\xae\x03\x93\x02\xac\x03\x90\x00\xe2\xfc\xff\xfc\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xe9\xfc\x43\x00\x44\x00\xea\xfc\xfe\xfc\x46\x00\xe3\xfc\x47\x00\x64\x03\x7d\x01\x44\x00\xe4\xfc\xaa\x03\x46\x00\xab\x03\x47\x00\xa8\x03\x4a\x00\xe6\x00\x4c\x00\x80\x00\xba\x01\x2b\x02\xca\x00\xa5\x03\xa9\x03\xa3\x03\xa4\x03\x9d\x03\x4d\x00\x81\x00\x93\x03\xda\x04\x82\x00\xbb\x01\xbc\x01\xbd\x01\xbe\x01\x83\x00\x63\x01\x9c\x00\x9d\x00\xb3\x02\x81\x03\x24\x02\xc1\x01\x95\x01\x79\x00\x80\x03\x7a\x00\x9e\x00\x71\x00\xc2\x01\x7e\x00\x72\x00\x73\x00\x4d\x01\xc3\x01\x7f\x03\x7d\x03\x89\x00\x8a\x00\x76\x03\x71\x03\x8c\x00\x8d\x00\x70\x03\x6f\x03\x6e\x03\x6d\x03\x6c\x03\x6b\x03\x6a\x03\x13\xfd\x69\x03\xc5\x04\x66\x03\x63\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\x62\x03\x54\x03\x60\x01\x51\x03\x48\x03\x11\x00\x43\x03\x7b\x00\x7c\x00\x41\x03\x3f\x03\xa0\x00\x35\x03\x88\x00\x1f\x03\x27\x01\x14\x03\xed\x00\xee\x00\xef\x00\xf0\x00\x1a\x03\x13\x03\x12\x03\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\x06\x01\x2c\x04\xeb\x00\xbe\x03\xe1\x03\x8d\x00\x2a\x04\x93\x02\x25\x04\x90\x00\x1f\x04\x1d\x04\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xa7\x02\x68\x01\x69\x01\x6a\x01\x1c\x04\x6b\x01\x37\x00\x19\x04\x1b\x04\x15\x01\x0a\xfd\x72\x00\x16\x01\x09\xfd\xc6\x04\x16\x04\x0b\xfd\x17\x04\xe6\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\xca\x00\x67\x03\x6a\x01\x14\x04\x6b\x01\x0a\x04\x04\x04\x4e\x03\x15\x01\xd9\x04\x72\x00\x16\x01\x17\x01\xff\x03\xfe\x03\x18\x01\xfc\x03\x9c\x00\x9d\x00\x2f\x02\x79\x00\x11\x00\x7a\x00\xf8\x03\x19\x01\xf4\x03\xa8\x02\x9e\x00\x71\x00\xf2\x03\xc3\x01\x72\x00\x73\x00\xb3\x02\x17\x01\xf0\x03\x6a\x00\x18\x01\x40\x00\xe6\x03\xd2\x03\x2a\x02\xe1\x03\x11\x00\xc9\x03\xd8\x03\x19\x01\xd1\x03\x92\x04\xc8\x03\x41\x00\x8a\x04\x58\x02\xbe\x03\x00\x01\xcd\x00\x9f\x00\x0f\x00\xce\x00\x84\x04\x00\x01\xff\x00\x81\x04\x7f\x04\x11\x00\x4e\x03\x7b\x00\x7c\x00\xb0\x01\x7b\x04\xa0\x00\x76\x03\x32\x04\x72\x04\x73\x04\x71\x04\xed\x00\xee\x00\xef\x00\xf0\x00\x70\x04\xfe\x03\xfc\x03\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\xfc\x03\x48\x04\xeb\x00\x42\x04\xff\x00\x8d\x00\x3d\x04\x93\x02\x39\x04\x90\x00\x38\x04\x36\x04\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x35\x04\x34\x04\x33\x04\x12\x03\x43\x00\x44\x00\x32\x04\x45\x00\x46\x00\xdd\x04\x47\x00\x48\x00\x49\x00\xdc\x04\xd8\x04\xd1\x04\xd7\x04\xcc\x04\xe6\x00\x00\x01\x4a\x00\x4b\x00\x4c\x00\xca\x00\x80\x00\x4c\x01\xac\xfe\x41\x01\xb6\x04\xac\xfe\xfc\x03\xad\x04\x4d\x00\xac\x04\x81\x00\xa2\x04\x14\x01\x82\x00\x16\x05\x23\x05\x9c\x00\x9d\x00\x83\x00\x18\x05\x0f\x05\x10\x05\x11\x05\x06\x05\x05\x05\x04\x05\x9e\x00\x71\x00\x02\x05\x01\x05\x72\x00\x73\x00\x00\x05\xff\x04\x50\x01\xe7\x04\x4d\x01\xf9\x04\x59\x05\x43\x03\x89\x00\x8a\x00\x53\x05\x52\x05\x8c\x00\x8d\x00\x6c\x05\x4c\x05\x3c\x05\x38\x05\x3d\x05\x00\x01\x2f\x05\x2e\x05\xcd\x00\x9f\x00\x0f\x00\xce\x00\x61\x05\x65\x05\xf4\x04\xff\x00\x2d\x05\x11\x00\x57\xfe\x7b\x00\x7c\x00\xfe\x03\xfc\x03\xa0\x00\x70\x05\x27\x05\x81\x05\xbe\x03\x5c\x05\xed\x00\xee\x00\xef\x00\xf0\x00\x6f\x05\xb7\x03\x7c\x05\xe8\x00\xe9\x00\x91\x02\xea\x03\x8b\x01\x71\x00\x88\x05\xeb\x00\x72\x00\x73\x00\x8d\x00\x5c\x05\x93\x02\xbe\x03\x90\x00\x87\x05\x37\x00\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xda\x02\x85\x05\xfc\x03\x82\x05\x8a\x05\x31\x01\x3d\x00\x3e\x00\x3f\x00\x8c\x01\x0f\x00\x10\x00\x04\x01\xb1\x01\xa9\x01\x37\x00\xc0\x01\x11\x00\xa5\x01\x7b\x00\x7c\x00\x85\x01\x7a\x01\xda\x02\x4d\x01\x36\x01\x2c\x01\x12\x01\x31\x01\x3d\x00\x3e\x00\x3f\x00\x04\x03\x00\x03\x03\x03\x02\x03\xfc\x02\xf9\x02\xf3\x02\xac\x02\x9c\x00\x9d\x00\xcb\x02\xba\x02\xe5\x02\xdf\x02\xa0\x02\x40\x00\x37\x00\xd5\x01\x9e\x00\x71\x00\x03\x02\xbb\x03\x72\x00\x73\x00\xda\x02\x16\x02\xfe\x01\x41\x00\xfb\x01\x31\x01\x3d\x00\x3e\x00\x3f\x00\x56\x02\xba\x03\x09\x03\x9f\x03\xb9\x03\x40\x00\x73\x02\x81\x03\x80\x00\x4c\x01\x51\x03\x77\x03\x51\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\x41\x00\x81\x00\x76\x03\x46\x03\x82\x00\x11\x00\x41\x03\x7b\x00\x7c\x00\x83\x00\x3f\x03\xa0\x00\x61\x02\x3d\x03\xa6\x03\x54\x02\x35\x03\xed\x00\xee\x00\xef\x00\xf0\x00\x40\x00\x1d\x03\x1b\x03\x1a\x03\x25\x03\x18\x03\x4d\x01\x10\x03\x0f\x03\x0c\x03\x89\x00\x8a\x00\x41\x00\x30\x04\x8c\x00\x8d\x00\x2f\x04\x43\x00\x44\x00\x2e\x04\x45\x00\x46\x00\x2d\x04\x47\x00\x48\x00\x49\x00\x2c\x04\x2a\x04\x1d\x04\x12\x04\x0f\x04\x0c\x04\x02\x04\x4a\x00\x4b\x00\x4c\x00\x04\x04\x37\x00\xfc\x03\x00\x04\x43\x00\x44\x00\xe6\x03\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\xbb\x02\x7b\x03\x3d\x00\x3e\x00\x3f\x00\x1b\x05\xdf\x03\x4a\x00\x4b\x00\x4c\x00\xbf\x03\xbe\x03\xbc\x03\x7f\x04\x7d\x04\x81\x00\x54\x02\x68\x04\x82\x00\x4d\x00\x4a\x05\x51\x04\x6d\x04\x83\x00\x43\x00\x44\x00\x46\x04\x45\x00\x46\x00\x36\x04\x47\x00\x48\x00\x49\x00\xe2\x04\xd8\x03\xdf\x04\xde\x04\xd2\x04\xd3\x04\xd1\x04\x4a\x00\x4b\x00\x4c\x00\x40\x00\xcf\x04\x89\x00\x1c\x05\xca\x04\xcc\x04\x8c\x00\x1d\x05\x37\x00\x4d\x00\xaa\x04\xbb\x04\x41\x00\xba\x04\x44\x01\xa2\x04\x45\x01\xb4\x04\x92\x04\x21\x05\x16\x05\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x13\x05\x20\x05\x37\x00\x12\x05\x02\x05\xfa\x04\xea\x04\xf3\x04\x59\x03\x59\x05\x5a\x03\xe5\x04\x46\x05\x53\x05\x4f\x05\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x49\x05\x4e\x05\x36\x05\x35\x05\x66\x05\x65\x05\x7e\x05\x7a\x05\xbc\x02\x87\x02\x76\x05\x74\x05\x37\x00\x83\x05\x85\x05\x8a\x05\x46\x02\x88\x02\xbd\x02\x40\x00\x3b\x00\x8a\x02\x88\x05\x00\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x43\x00\x44\x00\x41\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x87\x02\x00\x00\x40\x00\x37\x00\xc5\x01\x00\x00\x00\x00\x81\x00\x88\x02\x89\x02\x82\x00\x00\x00\x8a\x02\x00\x00\x41\x00\x83\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x01\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x63\x01\x47\x00\x48\x00\x49\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\xbf\x02\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x03\x4d\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x8c\x02\x00\x00\x8a\x02\x8d\x02\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x82\x00\xe8\x03\x4d\x00\x40\x00\x37\x00\x83\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x8d\x02\x41\x00\x62\x01\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x63\x01\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x40\x04\x8c\x00\x8d\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x80\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x8c\x02\x82\x00\x40\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x16\x03\x20\x01\x00\x00\x00\x00\x00\x00\x15\x01\x41\x00\x72\x00\x16\x01\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x4d\x01\x47\x00\x48\x00\x49\x00\x89\x00\x8a\x00\x00\x00\x40\x00\x8c\x00\x8d\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x17\x01\x00\x00\x00\x00\x18\x01\x41\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x11\x00\x00\x00\x00\x00\x19\x01\x00\x00\x00\x00\x00\x00\xd8\x04\x8c\x02\x00\x00\x37\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x8d\x02\x8d\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x83\x03\x00\x00\x96\x00\x97\x00\x48\x05\x84\x03\x4d\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x8d\x02\x00\x00\x8b\x02\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\x40\x05\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x8c\x02\x88\x02\x89\x02\x9c\x00\x9d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x11\x00\x40\x00\x7b\x00\x7c\x00\x37\x00\x00\x00\xa0\x00\x00\x00\x47\x01\x8d\x02\x00\x00\x07\x05\x00\x00\x41\x00\x08\x05\x09\x05\x0a\x05\x00\x00\x00\x00\x0b\x05\x3f\x00\x48\x01\x00\x00\x49\x01\x4a\x01\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x77\x00\x78\x00\x79\x00\x00\x00\x7a\x00\x00\x00\x0c\x05\x7d\x00\x7e\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x40\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x4d\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x05\x0a\x05\x00\x00\x4d\x00\x0b\x05\x3f\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x05\x00\x00\x00\x00\x0b\x05\x3f\x00\x00\x00\x63\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x80\x00\xf8\x04\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x81\x00\x00\x00\x00\x00\x82\x00\x4d\x00\x00\x00\x40\x00\x37\x00\x83\x00\x00\x00\x00\x00\x12\x02\xe3\x03\xbd\x02\x00\x00\x3b\x00\x8a\x02\x0d\x05\x41\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x4d\x01\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x37\x00\x00\x00\x00\x00\x00\x00\x11\x02\xe2\x03\xbd\x02\x00\x00\x3b\x00\x8a\x02\x00\x00\x00\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x0d\x05\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x02\x00\x00\x37\x00\x00\x00\x0d\x05\x00\x00\xb5\x03\x5b\x04\xbd\x02\x00\x00\x3b\x00\x8a\x02\x00\x00\x00\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\xbf\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x41\x00\x00\x00\xb7\x04\x00\x00\x31\x03\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\xb8\x04\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\xb7\x04\x00\x00\x31\x03\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\xbf\x02\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x3e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x41\x00\x47\x00\x48\x00\x49\x00\x80\x00\x00\x00\x3a\x04\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x40\x00\x00\x00\x00\x00\x83\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x01\x00\x00\x8c\x02\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\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\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x00\x00\x00\x00\x32\x03\x00\x00\x31\x03\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x30\x03\x00\x00\x31\x03\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x01\x00\x00\xc7\x01\x00\x00\x40\x00\xc8\x01\x00\x00\x00\x00\xc9\x01\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x03\x89\x02\x41\x00\x00\x00\x8a\x02\x00\x00\xca\x01\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xcb\x01\x00\x00\x00\x00\x18\x01\x40\x00\x47\x01\x00\x00\xcc\x01\x79\x00\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x00\x00\x41\x00\x00\x00\xb7\x02\x00\x00\x49\x01\x4a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x02\x76\x00\x00\x00\x77\x00\x78\x00\x79\x00\x40\x00\x7a\x00\x00\x00\x00\x00\x7d\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8d\x02\x8c\x02\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x03\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x04\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\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\x37\x00\x00\x00\x00\x00\x00\x00\x47\x01\x5b\x04\x89\x02\x41\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x48\x01\x00\x00\x49\x01\x4a\x01\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x77\x00\x78\x00\x79\x00\x00\x00\x7a\x00\x41\x00\x00\x00\x7d\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x02\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\x41\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8d\x02\x8c\x02\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x04\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x2e\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\xd2\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x40\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xd3\x01\xd4\x01\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\xd7\x01\x00\x00\x39\x00\x8c\x02\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x2f\x02\x79\x00\x4d\x00\x7a\x00\x00\x00\x00\x00\xc2\x01\x7e\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\xd5\x01\x47\x00\xd8\x01\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\xd7\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\xd9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xd5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x37\x00\x41\x00\x13\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x14\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x9e\x02\x00\x00\x00\x00\x00\x00\x40\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x42\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x41\x00\x47\x00\xd8\x01\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x5f\x05\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\xd9\x01\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x7a\x05\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x0e\x02\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x0b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x03\x00\x00\x00\x00\xf0\x03\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x03\x40\x00\x00\x00\xee\x03\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x03\x40\x00\x00\x00\xb0\x04\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x02\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xce\x02\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x38\x02\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xb2\x03\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xb1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\xaf\x03\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xae\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xc9\x03\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x14\x04\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\xdc\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x88\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x43\x05\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x10\x02\x37\x00\x00\x00\x14\x04\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x11\x04\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x0a\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\xf6\x03\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\xc3\x03\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x42\x04\x37\x00\x00\x00\xeb\x04\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x45\x05\x37\x00\x00\x00\x00\x00\x00\x00\x12\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\x11\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\xb5\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\xc4\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\xe7\x04\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x40\x00\xb2\x04\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\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\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x02\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\xcf\x02\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\xcd\x02\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x13\x02\x47\x00\x48\x00\x49\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x48\x03\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x4d\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\x37\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xff\x03\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\xe4\x03\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x41\x00\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x4d\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x6e\x04\x47\x00\x48\x00\x49\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x04\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x04\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\xf6\x04\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x39\x05\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xee\x01\x3f\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x40\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x4d\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x05\x02\xa3\x00\x13\x00\xa4\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x02\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x9a\x03\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xf6\x00\xd3\x00\x00\x00\xf7\x00\x00\x00\x15\x00\x00\x00\xf8\x00\x00\x00\x16\x00\xf9\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\xd8\x00\x00\x00\xfc\x00\xfd\x00\x00\x00\x00\x00\xfe\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x57\x04\x58\x04\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x59\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x4e\x04\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\xf7\x00\x00\x00\x15\x00\x00\x00\x4f\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x57\x04\x58\x04\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x59\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x4e\x04\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\xf7\x00\x00\x00\x15\x00\x00\x00\x4f\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x62\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x63\x01\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x95\x01\xb6\x00\x00\x00\x00\x00\x63\x01\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x62\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x63\x01\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x3c\x02\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x23\x02\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x3f\x02\xb6\x00\x00\x00\x00\x00\x23\x02\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x9a\x01\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\xb3\x02\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x23\x02\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\xd8\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\xd8\xfd\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\xd7\xfd\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\xd7\xfd\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xd4\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\xb0\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x01\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x03\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x9a\x03\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\xaa\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x90\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x9a\x03\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\xaa\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x90\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\xdc\x03\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\xa3\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x86\x03\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\xa3\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\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\x2a\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\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x4f\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x63\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\xdc\x01\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x01\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x63\x01\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x02\x58\x00\x59\x00\x33\x02\x00\x00\x00\x00\x00\x00\x00\x00\x34\x02\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x62\x01\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x01\x61\x00\x62\x00\x63\x00\x64\x00\x35\x02\x36\x02\x00\x00\x67\x00\x68\x00\x37\x02\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\xba\x04\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\xde\x01\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x34\x01\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\x35\x01\x36\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\xc8\x04\x00\x00\x6e\x00\x6f\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\xc9\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x04\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x04\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x45\x05\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x4f\x00\x13\x00\x6b\x00\x6c\x00\x8d\x00\xdd\x00\x8f\x00\x00\x00\x90\x00\x14\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xfe\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x9f\x00\x0f\x00\x10\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x11\x00\x60\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\xa1\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x5c\x03\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\x00\x8d\x00\xb8\x01\x8f\x00\x00\x00\x90\x00\x14\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x9f\x00\x0f\x00\x10\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x11\x00\x60\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\xa1\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x5c\x03\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\x00\x8d\x00\xb2\x01\x8f\x00\x00\x00\x90\x00\x14\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x9f\x00\x0f\x00\x10\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x11\x00\x60\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\xa1\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\x00\x8d\x00\x00\x00\x89\x01\x00\x00\x90\x00\x14\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x9f\x00\x0f\x00\x10\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x11\x00\x60\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x01\x00\x00\xc5\x01\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x83\x01\x0f\x00\x10\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x11\x00\x60\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\x13\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x14\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x2a\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x01\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x2c\x00\x6e\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x2e\x03\x17\x00\x18\x00\x19\x00\x2b\x03\x2c\x03\x2d\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x03\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\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x03\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\xa8\x04\x2a\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\x0c\x02\x0d\x02\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\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\x2a\x00\x8d\x00\x00\x00\x00\x00\xc1\x02\xc2\x02\x00\x00\xc3\x02\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x0c\x02\x0d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x4e\x03\xc2\x02\x0e\x02\xc3\x02\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x0e\x02\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x14\x00\x00\x00\x00\x00\xc4\x02\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\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\xc4\x02\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x01\x53\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x59\x01\x95\x01\x5b\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x5c\x01\x7e\x00\xa0\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\xa1\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x01\x53\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x59\x01\x5a\x01\x5b\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x5c\x01\x7e\x00\xa0\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\xa1\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x01\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x13\x00\x00\x00\x93\x01\x8d\x00\x5e\x01\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x8e\x01\x00\x00\x96\x00\x97\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\x2a\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\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\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x83\x01\x0f\x00\x10\x00\xce\x01\x00\x00\x00\x00\x00\x00\xcf\x01\x11\x00\x86\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\xd0\x01\x00\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x00\x00\x8b\x00\x00\x00\x8d\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x13\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x01\x14\x00\x00\x00\x00\x00\x97\x01\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x04\x00\x00\x00\x00\x15\x00\x00\x00\x9e\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\x9c\x00\x9d\x00\x9f\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\xa0\x04\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x6c\x02\x2d\x00\x67\x00\x6d\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x02\x00\x00\x00\x00\x86\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x88\x03\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\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\x8a\x03\x8b\x03\x8c\x03\x8d\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\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x94\x03\x95\x03\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x77\x04\x8c\x03\x8d\x03\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x98\x03\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x03\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x03\x01\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x9a\x00\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x5c\x02\x00\x00\x00\x00\x5b\x02\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x5b\x02\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x51\x02\x52\x02\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x02\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x9a\x03\x95\x03\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x49\x03\x52\x02\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x02\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\xd2\x03\x95\x03\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x8d\x00\xab\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\xac\x01\xad\x01\xae\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x03\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x75\x04\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x04\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x03\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x7b\x04\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x20\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x1f\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8a\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x84\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x4d\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x44\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x43\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x42\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x41\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xa1\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xa0\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x90\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x4a\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xe9\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xda\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xd9\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xce\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xcc\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x7c\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x74\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x5a\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdd\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xaf\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xae\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xad\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x11\x05\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x38\x05\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x02\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\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\xa1\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\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x04\x00\x00\x00\x00\x15\x00\x00\x00\x9e\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\x9f\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\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\xa0\x04\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa1\x04\x00\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x13\x00\x2d\x00\x67\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\x9e\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\x84\x00\x00\x00\x24\x00\x00\x00\x8e\x01\x00\x00\x86\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x13\x00\x2d\x00\x8b\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\x2c\x05\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\xa0\x04\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\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\x2a\x00\x00\x00\xce\x01\x13\x00\x00\x00\x00\x00\xcf\x01\x00\x00\x86\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\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\x2a\x00\x00\x00\x80\x01\x13\x00\x00\x00\x00\x00\x81\x01\x00\x00\x82\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x00\x00\x8b\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\x2a\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\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x4d\x02\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\x2b\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\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\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x13\x00\x00\x00\x00\x00\x6d\x01\x62\x01\x86\x00\x00\x00\x00\x00\x14\x00\x00\x00\x63\x01\x00\x00\x00\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x1b\x01\x00\x00\x00\x00\x15\x00\x00\x00\x1c\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x1d\x01\x13\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x2c\x00\x88\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\x84\x00\x00\x00\x24\x00\x00\x00\x6d\x01\x13\x00\x86\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x2c\x00\x88\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\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x2c\x01\x13\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x2c\x00\x88\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\x84\x00\x00\x00\x24\x00\x00\x00\x1d\x01\x13\x00\x86\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x2c\x00\x88\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\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x6d\x01\x13\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x2c\x00\x88\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\x84\x00\x00\x00\x24\x00\x00\x00\x1d\x01\x13\x00\x86\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x2c\x00\x88\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\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\x2a\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\x2c\x00\x88\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\xff\x14\x00\x00\x00\x00\x00\x05\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\xec\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\xaf\x02\x00\x00\x24\x00\x2c\x00\x00\x00\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\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\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\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\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\xed\x01\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xb4\x02\x14\x00\x90\x00\x00\x00\x63\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x04\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x63\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x00\x00\x23\x04\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\xed\x01\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x00\x00\xc9\x04\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x71\x00\x00\x00\x8d\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x64\x02\x65\x02\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\x71\x00\x00\x00\x8d\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x64\x02\x93\x03\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\x71\x00\x00\x00\x8d\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x9e\x01\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\x8d\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x01\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xa8\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xa4\x01\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9a\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xfe\x02\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\x02\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xb6\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x4e\x02\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x03\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x82\x01\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\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"#+happyTable = HappyA# "\x00\x00\x6f\x00\x73\x05\x54\x03\x32\x05\x33\x05\x95\x04\x8d\x04\x75\x05\xc9\x00\x88\x04\x85\x04\x84\x04\x85\x04\x86\x04\x06\x01\x86\x04\x07\x01\xf4\x03\x18\x05\x2f\x05\x30\x05\x86\x04\x08\x01\x09\x01\x0a\x01\x2d\x00\x2e\x00\x5d\x05\x0b\x01\x07\x02\x08\x02\x09\x02\xe9\x02\x2f\x00\x77\x05\x30\x00\x80\x02\x78\x05\xa6\x04\x08\x02\x09\x02\xa5\x04\x08\x02\xc2\x03\x14\x05\xa6\x04\x08\x02\x09\x02\xa6\x04\x08\x02\x09\x02\xca\x00\x23\x03\x8a\x04\x8b\x04\x8c\x04\x8d\x04\x5a\x05\x8b\x04\x8c\x04\x8d\x04\xe6\x01\x7f\x05\x8b\x04\x8c\x04\x8d\x04\x27\x03\x28\x03\x70\x05\x71\x05\x8d\x04\x77\x02\x78\x02\x23\x05\x8d\x04\x77\x02\x78\x02\x19\x05\x8d\x04\x60\x04\x69\x04\x6a\x04\x81\x04\xe0\x01\x3c\x03\x05\x02\xc1\xff\x05\x02\xc1\xff\x44\x04\x55\x03\x1f\x04\x20\x04\xc1\xff\x3b\x04\x20\x04\x6f\x02\x88\x04\x7c\x05\x73\x01\x40\x00\x34\x00\x87\x03\x4b\x03\xbc\xff\xf5\x03\x05\x02\x4f\x01\x2e\x01\xc7\xfc\x05\x02\x57\x05\x41\x00\x4e\x03\xa6\x02\x5e\x05\x5d\x03\x60\x01\x05\x02\xe6\x02\xc1\xff\x96\x04\xc1\xff\x88\x04\x2f\x01\x68\x05\x97\x04\x98\x04\x27\x05\x28\x05\x29\x05\x2a\x05\x98\x04\x05\x02\xec\x04\x72\x05\x2a\x05\x98\x04\xfa\x01\xb7\x02\x2a\x02\xcb\x00\x0e\x03\x0f\x03\x8d\x00\x63\x01\xcc\x00\xfb\x02\x90\x00\x3c\xfe\xb0\x01\x92\x00\x93\x00\x94\x00\x95\x00\x84\x02\x96\x00\x97\x00\x54\x02\x50\x01\xff\x00\x69\x05\x06\x01\xa7\x02\x33\x00\x5e\x03\xa6\x03\xb0\x01\x2b\x02\x69\x02\xca\x02\x0d\x01\xfb\x01\x43\x00\x44\x00\x6a\x02\x34\x00\x46\x00\x21\x03\x47\x00\x4c\x03\xfc\x02\xbc\xff\x71\x01\xff\x00\x06\x02\x70\x02\x06\x02\x71\x02\x4a\x00\xf8\x01\x4c\x00\x70\x02\x61\x04\xe8\x04\x20\x04\x3d\x03\x3f\x04\x9c\x00\x9d\x00\x34\x00\x4d\x00\x34\x00\x6b\x02\x58\x05\xf7\x01\x06\x02\x34\x00\x9e\x00\x71\x00\x06\x02\xe1\x01\x72\x00\x73\x00\xe1\x01\x07\x02\xdd\x03\xe2\x01\x06\x02\x9f\x03\x6b\x04\x29\x03\x7a\x02\xea\x02\x18\x01\xe1\x01\x79\x02\x75\x03\x55\x02\x11\x00\x11\x00\x56\x03\x27\x01\x06\x02\x37\x00\xde\x02\xcd\x00\x9f\x00\x0f\x00\xce\x00\xe1\x01\x81\x02\x73\x03\xea\x02\xde\x03\x11\x00\x56\x03\x7b\x00\x7c\x00\x11\x00\xe1\x01\xa0\x00\x58\xff\x82\x02\x83\x02\x50\x05\x56\x03\x70\x00\x71\x00\x2e\x03\x21\x04\x72\x00\x73\x00\x21\x04\x74\x00\x4d\x00\x11\x00\xdf\x02\x8f\x02\x11\x00\xcc\x01\x79\x00\xff\xff\x7a\x00\x1d\x01\x1e\x01\x8e\x04\x84\x02\x8f\x04\x90\x04\x75\x00\x62\x04\x63\x04\x47\x00\x58\xff\x19\x04\x0e\x00\x0f\x00\x10\x00\x76\x00\x31\x05\x77\x00\x78\x00\x79\x00\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x34\x05\x45\x04\x0f\x01\x34\x05\x31\x00\x19\x02\x31\x00\x31\x00\xff\xff\x31\x05\x45\x04\x4d\x00\x31\x00\xfd\x01\x31\x00\x0a\x02\x31\x00\xfe\x01\x90\xfe\x15\x03\x4d\x00\x90\xfe\x0e\x01\x53\x03\x0a\x02\x92\xfe\x8e\x04\x0a\x02\x8f\x04\x90\x04\x8e\x04\x0a\x02\x8f\x04\x90\x04\x0a\x02\x8e\x04\x17\x03\x8f\x04\x90\x04\x61\x05\x8e\x04\xdf\x03\x8f\x04\x90\x04\x8e\x04\xed\x04\x8f\x04\x90\x04\x8e\x04\xb9\x02\x8f\x04\x90\x04\x99\x04\x05\x02\x9a\x04\x4d\x00\x47\x00\x99\x04\xf5\x01\x9a\x04\xd9\x02\x47\x00\x99\x04\x21\x04\x9a\x04\x22\x03\x47\x00\x80\x00\x18\x01\x11\x00\x9b\x04\x0f\x00\x10\x00\x00\x01\x11\x00\x9b\x04\x0f\x00\x10\x00\x11\x00\xb5\x03\x9b\x04\x0f\x00\x10\x00\x11\x00\x22\x03\xc9\x00\xf5\x02\x18\x01\x11\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\x11\x00\xe2\x00\x28\x01\x29\x01\x72\x00\x16\x01\x05\x02\x79\x03\xe8\x02\xe9\x01\xea\x01\xc7\xfc\xff\xff\x8a\x00\x1f\x01\x20\x01\xf6\x02\xe3\x00\x7a\x03\x15\x01\x29\x03\x72\x00\x16\x01\x18\x01\x1a\x02\xe4\x00\xe5\x00\x18\x01\x37\x00\x11\x00\xe6\x00\x2a\x01\x10\x04\x11\x00\xff\x00\xca\x00\xda\x02\x11\x00\xf1\x01\x7a\x03\x19\x01\x31\x01\x3d\x00\x3e\x00\x3f\x00\x17\x01\x29\x03\xf2\x01\x18\x01\x18\x01\xa2\x02\xde\x01\xdf\x01\xe0\x01\x11\x00\x11\x00\xf7\x02\x19\x01\x1f\x01\x20\x01\x06\x02\x1a\x02\xe7\x00\x15\x01\x18\x01\x72\x00\x16\x01\x58\x03\xc7\xfc\xcf\x04\x11\x00\x1d\x05\x71\x00\x23\x01\x20\x01\x72\x00\x73\x00\xa3\x02\x15\x01\xe1\x01\x72\x00\x16\x01\x26\x04\x40\x00\x60\x01\x6b\x04\x05\x02\xa4\x02\xe5\x01\x17\x01\xf8\x02\xf5\x02\x18\x01\x15\x02\xea\x01\x41\x00\x7e\x02\x49\x00\x11\x00\xee\x01\xbc\x04\x19\x01\x7a\x03\xea\x01\x17\x01\x27\x04\x06\x02\x18\x01\x73\x02\x34\x00\x7b\x00\x7c\x00\x63\x01\x11\x00\xf6\x02\xc5\x04\x19\x01\x42\x05\xe8\x00\xe9\x00\xea\x00\x2f\x01\xff\x00\x4f\x03\xea\x01\xeb\x00\xd9\x01\x40\x00\x8d\x00\x35\x00\xec\x00\xeb\x01\x90\x00\x4c\x00\xf2\x02\x92\x00\x93\x00\x94\x00\x95\x00\x41\x00\x96\x00\x97\x00\xc9\x00\x4d\x00\x1f\x02\xa9\x04\x82\x03\xdf\x00\xe0\x00\xe1\x00\xa2\x01\xe2\x00\x20\x02\xeb\x01\x05\x02\x4c\x00\x43\x00\x44\x00\x05\x02\x45\x00\x46\x00\xa3\x01\x47\x00\x48\x00\x49\x00\x4d\x00\xc9\x02\xe3\x00\xf3\x02\xca\x02\x33\x03\xea\x01\x4a\x00\x4b\x00\x4c\x00\xe4\x00\xe5\x00\xf2\x03\xea\x01\xaa\x04\xe6\x00\xe1\x01\x9c\x00\x9d\x00\x4d\x00\xca\x00\x06\x02\xe2\x01\x62\x04\x63\x04\x47\x00\x0d\x01\x9e\x00\x71\x00\x37\x00\xa5\x04\x72\x00\x73\x00\xc2\x01\x7e\x00\x43\x00\x44\x00\x30\x01\xc3\x01\x46\x00\xe4\x04\x47\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x0e\x01\xe7\x00\x21\x01\x22\x01\xeb\x01\x4a\x00\x4c\x00\x4c\x00\xa2\x02\xcd\x00\x9f\x00\x0f\x00\xce\x00\xeb\x01\x0e\x01\x4c\x00\x4d\x00\x4d\x00\x11\x00\x95\x01\x7b\x00\x7c\x00\x80\x00\x63\x01\xa0\x00\x4d\x00\x18\x02\xeb\x01\x9a\x01\x4c\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xeb\x01\xa3\x02\x4c\x00\x19\x02\x40\x00\x4d\x00\x43\x01\x06\x05\xea\x01\x06\x02\x89\xfd\x1d\x03\x4d\x00\x06\x02\xf6\x01\x62\x01\x41\x00\x7e\x03\x75\x03\x92\xfe\xe9\x01\x63\x01\x4e\x05\xe8\x00\xe9\x00\xea\x00\xc9\x00\x8a\x00\x0f\x02\xf7\x01\xeb\x00\x41\x05\x05\x03\x8d\x00\xd0\x01\xec\x00\x47\x00\x90\x00\xe8\x01\x07\x02\x92\x00\x93\x00\x94\x00\x95\x00\x9e\x03\x96\x00\x97\x00\xeb\x01\xd1\x01\x4c\x00\x48\x04\x49\x04\x06\x03\x07\x03\xeb\x01\x9f\x03\x4c\x00\x37\x00\x4d\x00\x4d\x00\x28\x04\xff\xff\xe3\x04\x44\x01\xe6\x00\x45\x01\x4d\x00\x00\x01\x29\x04\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x4a\x04\x4f\x04\x46\x01\x43\x00\x32\x01\x81\x02\x45\x00\x46\x00\x0e\x01\x47\x00\x48\x00\x49\x00\x98\xfe\x9c\x00\x9d\x00\x98\xfe\x3c\x02\xe1\x03\x83\x02\x4a\x00\x4b\x00\x4c\x00\x23\x02\x9e\x00\x71\x00\x23\x01\x20\x01\x72\x00\x73\x00\x74\x03\x15\x01\x4d\x00\x72\x00\x16\x01\xcc\x01\x79\x00\x2d\x02\x7a\x00\x40\x00\xb6\x01\x75\x03\x84\x02\x11\x00\x25\x05\x80\x00\x25\x03\x64\x01\xc0\x04\x72\x00\x16\x01\x41\x00\xcd\x00\x9f\x00\x0f\x00\xce\x00\xeb\x01\x17\x01\x4c\x00\xf7\x01\x18\x01\x11\x00\x81\x00\x7b\x00\x7c\x00\x82\x00\x11\x00\xa0\x00\x4d\x00\x19\x01\x83\x00\xb5\x01\x62\x01\xed\x00\xee\x00\xef\x00\xf0\x00\x24\x05\x63\x01\xe8\x00\xe9\x00\x91\x02\x4c\x04\xc9\x00\x8a\x00\x19\x01\xeb\x00\xff\xff\x8d\x00\x8d\x00\x89\x00\x93\x02\xf7\x01\x90\x00\xca\x03\x4a\x02\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x64\x01\x29\x01\x72\x00\x16\x01\x48\x04\x49\x04\xff\x01\x37\x03\x38\x03\x43\x00\x44\x00\x81\x00\x45\x00\x46\x00\x82\x00\x47\x00\x48\x00\x49\x00\xe6\x00\x83\x00\x72\x03\x00\x02\x01\x02\xca\x00\x25\x02\x4a\x00\x4b\x00\x4c\x00\x4a\x04\x4b\x04\x26\x02\x73\x03\x47\x01\xb4\x01\x4b\x02\x0f\x00\x10\x00\x4d\x00\x19\x01\x89\x00\x9c\x00\x9d\x00\x11\x00\x8c\x00\x14\x02\x48\x01\x4c\x00\x49\x01\x4a\x01\xa4\x01\x9e\x00\x71\x00\xa1\x01\x65\x04\x72\x00\x73\x00\x4d\x00\x76\x00\xd8\x02\x77\x00\x78\x00\x79\x00\x2d\x02\x7a\x00\x6a\x05\x7c\x01\x7d\x00\x7e\x00\x11\x00\x64\x00\xbf\x01\x7c\x00\x6b\x05\x67\x00\xc2\x04\xbe\x04\xbf\x04\x68\x04\xcd\x00\x9f\x00\x0f\x00\xce\x00\x66\x04\x67\x04\xbd\x04\xbe\x04\xbf\x04\x11\x00\x64\x00\x7b\x00\x7c\x00\x22\x02\x67\x00\xa0\x00\x48\x02\x49\x02\x4a\x02\x23\x02\xff\xff\xed\x00\xee\x00\xef\x00\xf0\x00\x07\x04\x80\x00\x4c\x00\xe8\x00\xe9\x00\x91\x02\x4c\x04\xc9\x00\x0e\x03\x0f\x03\xeb\x00\x81\x00\x4d\x00\x8d\x00\x82\x00\x93\x02\x18\x02\x90\x00\xce\x04\x83\x00\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x19\x02\x62\x01\xcf\x04\x3f\x05\xbe\x04\xbf\x04\x68\x04\x63\x01\x4b\x02\x0f\x00\x10\x00\xc4\x04\x89\x00\x8a\x00\x6d\x05\xed\x02\x11\x00\x64\x00\xe6\x00\xee\x02\x6e\x05\x67\x00\xc5\x04\xca\x00\x67\x03\x6a\x01\x80\x01\x6b\x01\x81\x01\x79\x01\x82\x01\x15\x01\x9a\x02\x72\x00\x16\x01\x64\x01\xc0\x04\x72\x00\x16\x01\x64\x00\x9c\x00\x9d\x00\xb0\x01\x67\x00\xd7\x03\x64\x01\xc0\x04\x72\x00\x16\x01\x17\x04\x9e\x00\x71\x00\x18\x01\xd8\x02\x72\x00\x73\x00\xe1\x01\x17\x01\x11\x00\x84\x00\x18\x01\x2c\x01\x1c\x02\x86\x00\x64\x00\x09\x03\x11\x00\xc7\xfc\x67\x00\x19\x01\x79\x04\x7a\x04\x88\x00\x19\x01\xf1\x04\xef\x04\x0a\x03\x0b\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\xe1\x01\x19\x01\x43\x03\x44\x03\x45\x03\x11\x00\xc1\x04\x7b\x00\x7c\x00\xff\x00\xe1\x01\xa0\x00\x64\x01\xc0\x04\x72\x00\x16\x01\xc1\x04\xed\x00\xee\x00\xef\x00\xf0\x00\xf0\x01\x80\x00\x92\xfe\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\x86\x02\xe7\x03\xeb\x00\x81\x00\x18\x01\x8d\x00\x82\x00\x93\x02\x14\xfd\x90\x00\x11\x00\x83\x00\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x3e\x01\x71\x01\x19\x01\x84\x00\xa4\x04\x2c\x01\x37\x00\x86\x00\x87\x02\xfc\x04\xfd\x04\xe1\x01\x89\x00\x8a\x00\xda\x02\xa5\x04\x88\x00\xc1\x04\xe6\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\xca\x00\x80\x00\xff\x00\x56\x00\x01\x01\x02\x01\x3f\x01\x40\x01\x41\x01\x90\x02\xdb\x01\x81\x00\xff\xff\x57\x00\x82\x00\x9b\x02\x98\x02\x99\x02\x9d\x00\x83\x00\x43\x01\x5b\x00\x2f\x02\x79\x00\xe3\x01\x7a\x00\xea\x04\x9e\x00\x71\x00\xa8\x02\x80\x02\x72\x00\x73\x00\xc3\x01\x42\x01\x4d\x01\x63\x01\x75\x03\x40\x00\x89\x00\x8a\x00\x65\x00\x66\x00\x8c\x00\x8d\x00\x68\x00\x69\x00\xee\x02\x4d\x05\xef\x02\x41\x00\x64\x01\x65\x01\x72\x00\x16\x01\xcd\x00\x9f\x00\x0f\x00\xce\x00\x4e\x05\x0e\x00\x0f\x00\x10\x00\x40\x00\x11\x00\x76\x02\x7b\x00\x7c\x00\x11\x00\x27\x01\xa0\x00\x64\x01\x63\x03\x72\x00\x16\x01\x41\x00\xed\x00\xee\x00\xef\x00\xf0\x00\x6d\x01\x0f\x00\x10\x00\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\x11\x00\x19\x01\xeb\x00\xd6\x02\x26\x03\x8d\x00\x46\x00\x93\x02\x47\x00\x90\x00\x11\x00\x14\x01\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x3a\x04\x52\x04\x19\x01\xff\xff\x43\x00\x44\x00\x11\x00\x45\x00\x46\x00\xe1\x01\x47\x00\x48\x00\x49\x00\x12\x01\x2f\x03\xb6\x04\xff\xff\x46\x00\xe6\x00\x47\x00\x4a\x00\x4b\x00\x4c\x00\xca\x00\x53\x04\x59\x04\x56\x00\x7e\x02\xff\xff\x43\x00\x44\x00\x63\x01\x4d\x00\x46\x00\x11\x01\x47\x00\x57\x00\x03\x02\x97\x02\x98\x02\x99\x02\x9d\x00\x3f\x02\x09\x03\x5b\x00\x4a\x00\x23\x02\x4c\x00\x27\x02\x02\x03\x9e\x00\x71\x00\x23\x02\x1b\x05\x72\x00\x73\x00\x00\x03\x4d\x00\xfd\x01\xa4\x02\x0f\x00\x10\x00\xfe\x01\x81\x00\x65\x00\x66\x00\x82\x00\x11\x00\x68\x00\x69\x00\xa8\x02\x83\x00\x64\x00\xc5\x03\xc3\x01\xbe\x01\x10\x00\xc6\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\x11\x00\x1f\x05\xbf\x01\x7c\x00\x46\x00\x11\x00\x47\x00\x7b\x00\x7c\x00\x89\x00\x1c\x05\xa0\x00\xc5\x03\x8c\x00\x1d\x05\xf9\x02\x82\x04\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x02\x80\x00\x7a\x01\xe8\x00\xe9\x00\x91\x02\x55\x04\xc9\x00\x58\x03\xe9\x02\xeb\x00\x81\x00\xc5\x03\x8d\x00\x82\x00\x93\x02\x3d\x05\x90\x00\xdd\x02\x83\x00\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xf0\x01\x52\x04\x84\x00\xa7\x01\x1f\x05\xa8\x01\x86\x00\xd5\x02\x4d\x01\xc5\x02\xc6\x02\xc7\x02\x89\x00\x8a\x00\xd1\x02\x88\x00\x8c\x00\x8d\x00\xe6\x00\x8b\x00\x38\x03\x39\x03\x3a\x03\xca\x00\x53\x04\x54\x04\x2f\x02\x79\x00\xc6\x01\x7a\x00\xc7\x01\x37\x00\x77\x01\xc8\x01\x78\x01\xd4\x02\xc9\x01\x59\x03\xd3\x02\x5a\x03\x9c\x00\x9d\x00\x0e\x03\x0f\x03\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xca\x01\xd2\x02\x9e\x00\x71\x00\x14\x01\xcd\x02\x72\x00\x73\x00\x15\x01\xcb\x01\x72\x00\x16\x01\x18\x01\xf8\x03\xf9\x03\xfa\x03\xcc\x01\x79\x00\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xfc\x04\x48\x05\xee\x04\xef\x04\xf5\x01\xf3\x01\xcd\x00\x9f\x00\x0f\x00\xce\x00\x17\x01\xf2\x01\xf3\x01\x18\x01\x40\x00\x11\x00\x50\x01\x7b\x00\x7c\x00\x11\x00\xcb\x02\xa0\x00\x19\x01\x9f\x02\x0f\x00\x10\x00\x41\x00\xed\x00\xee\x00\xef\x00\xf0\x00\x11\x00\x80\x00\xba\x02\xe8\x00\xe9\x00\x91\x02\x55\x04\xc9\x00\xc5\x01\xb9\x02\xeb\x00\x81\x00\xb6\x02\x8d\x00\x82\x00\x93\x02\xa7\x01\x90\x00\xa8\x01\x83\x00\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x87\x01\x62\x01\x88\x01\x3e\x02\x48\x04\x49\x04\x37\x00\x63\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x89\x00\x8a\x00\xda\x02\xb4\x02\x8c\x00\x8d\x00\xe6\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\xca\x00\x6c\x04\xf9\x03\xfa\x03\xae\x02\xf5\x04\x43\x00\x44\x00\x00\xfd\x45\x00\x46\x00\x3d\x02\x47\x00\x48\x00\x49\x00\x74\x01\xaa\x01\x9c\x00\x9d\x00\x5f\x04\xf9\x03\xfa\x03\x4a\x00\x4b\x00\x4c\x00\x73\x01\x6f\x01\x9e\x00\x71\x00\x74\x01\x75\x01\x72\x00\x73\x00\xaf\x02\x4d\x00\xd3\x03\xd4\x03\xd5\x03\x40\x00\xae\x01\x71\x01\x6f\x01\x7c\x01\x7d\x01\x44\x00\xab\x02\x77\x01\x46\x00\x78\x01\x47\x00\x41\x00\x6e\x01\x6f\x01\xaf\x02\x10\x00\xcd\x00\x9f\x00\x0f\x00\xce\x00\x7e\x01\x11\x00\x4c\x00\xbf\x01\x7c\x00\x11\x00\xac\x02\x7b\x00\x7c\x00\x24\x01\x25\x01\xa0\x00\x4d\x00\x9c\x02\x0f\x00\x10\x00\xaa\x02\xed\x00\xee\x00\xef\x00\xf0\x00\x11\x00\x74\x01\x01\x04\xe8\x00\xe9\x00\x91\x02\x4c\x04\xc9\x00\x59\x02\x63\x02\xeb\x00\x64\x02\x0e\x04\x8d\x00\x0f\x04\x93\x02\x06\x04\x90\x00\x07\x04\xde\x01\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x77\x01\x52\x04\x78\x01\x7d\x02\x43\x00\x44\x00\x6f\x02\x45\x00\x46\x00\x7c\x02\x47\x00\x48\x00\x49\x00\xe1\x02\xe2\x02\xe3\x02\xe4\x02\xe5\x02\xe6\x00\x47\x02\x4a\x00\x4b\x00\x4c\x00\xca\x00\xfd\x04\x66\x03\x68\x01\x69\x01\x6a\x01\xc1\x03\x6b\x01\xc2\x03\x4d\x00\xc6\x01\x15\x01\xc7\x01\x72\x00\x16\x01\xc8\x01\x77\x02\x9c\x00\x9d\x00\xb3\x04\xf9\x03\xfa\x03\xc1\x01\x95\x01\x79\x00\x75\x02\x7a\x00\x9e\x00\x71\x00\xc2\x01\x7e\x00\x72\x00\x73\x00\x6c\x02\xc3\x01\x40\x00\x5e\x04\x17\x01\x5f\x04\xcb\x01\x18\x01\x67\x02\x18\x01\x7d\x05\xf9\x03\xfa\x03\x11\x00\x41\x00\x11\x00\x19\x01\x7b\x00\x7c\x00\x82\x05\xf9\x03\xfa\x03\xcd\x00\x9f\x00\x0f\x00\xce\x00\xc1\x01\x95\x01\x79\x00\x68\x02\x7a\x00\x11\x00\x61\x02\x7b\x00\x7c\x00\x5f\x03\x60\x03\xa0\x00\xc1\x01\x95\x01\x79\x00\x5a\x02\x7a\x00\xed\x00\xee\x00\xef\x00\xf0\x00\x3e\x04\x60\x02\x3f\x04\xe8\x00\xe9\x00\x91\x02\x55\x04\xc9\x00\x5f\x02\xe1\x04\xeb\x00\xe2\x04\xd5\x04\x8d\x00\xd6\x04\x93\x02\x94\x04\x90\x00\x95\x04\x5e\x02\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\x59\x02\x43\x00\x44\x00\x58\x02\xe1\x04\x46\x00\xe2\x04\x47\x00\x64\x03\x7d\x01\x44\x00\xb0\x01\x50\x02\x46\x00\xae\x01\x47\x00\x50\x02\x4a\x00\xe6\x00\x4c\x00\x3b\x01\x3c\x01\x41\x02\xca\x00\x66\x01\x67\x01\x68\x01\x69\x01\x6a\x01\x4d\x00\x6b\x01\x40\x02\xda\x04\x2d\x02\x15\x01\x3e\x02\x72\x00\x16\x01\x7e\x02\x49\x00\x9c\x00\x9d\x00\xeb\x03\xec\x03\x3d\x02\x50\x04\x45\x03\x54\x05\x55\x05\x3b\x02\x9e\x00\x71\x00\x2c\x02\x29\x02\x72\x00\x73\x00\x28\x02\x24\x02\x21\x02\x1e\x02\x17\x01\x03\x02\x06\x01\x18\x01\xf5\x01\xb9\x03\xb8\x03\xb7\x03\xb4\x03\x11\x00\xae\x03\xac\x03\x19\x01\xad\x03\xe2\xfc\xc5\x04\xff\xfc\xe9\xfc\xcd\x00\x9f\x00\x0f\x00\xce\x00\xea\xfc\xaa\x03\xfe\xfc\xe3\xfc\xe4\xfc\x11\x00\xab\x03\x7b\x00\x7c\x00\xa5\x03\xa8\x03\xa0\x00\x2b\x02\xa3\x03\x9d\x03\xb3\x02\xa9\x03\xed\x00\xee\x00\xef\x00\xf0\x00\x81\x03\xa4\x03\x93\x03\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\x63\x01\x24\x02\xeb\x00\x80\x03\x7f\x03\x8d\x00\x7d\x03\x93\x02\x71\x03\x90\x00\x76\x03\x70\x03\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xa7\x02\x68\x01\x69\x01\x6a\x01\x6f\x03\x6b\x01\x37\x00\x6d\x03\x6c\x03\x15\x01\x6b\x03\x72\x00\x16\x01\x6e\x03\xc6\x04\x6a\x03\x66\x03\x69\x03\xe6\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\xca\x00\x54\x03\x60\x01\x16\x03\x20\x01\x51\x03\x63\x03\x62\x03\x15\x01\xd9\x04\x72\x00\x16\x01\x17\x01\x48\x03\x13\xfd\x18\x01\x43\x03\x9c\x00\x9d\x00\x2f\x02\x79\x00\x11\x00\x7a\x00\x3f\x03\x19\x01\x41\x03\xa8\x02\x9e\x00\x71\x00\x35\x03\xc3\x01\x72\x00\x73\x00\x1f\x03\x17\x01\x27\x01\x88\x00\x18\x01\x40\x00\x14\x03\x1a\x03\x13\x03\x12\x03\x11\x00\x06\x01\xe1\x03\x19\x01\xbe\x03\x2c\x04\x2a\x04\x41\x00\x25\x04\x1f\x04\x1d\x04\x1b\x04\xcd\x00\x9f\x00\x0f\x00\xce\x00\x19\x04\x0a\xfd\x1c\x04\x09\xfd\x0b\xfd\x11\x00\x17\x04\x7b\x00\x7c\x00\x16\x04\x0a\x04\xa0\x00\x14\x04\x04\x04\x4e\x03\xff\x03\xfe\x03\xed\x00\xee\x00\xef\x00\xf0\x00\xfc\x03\xf8\x03\xf4\x03\xe8\x00\xe9\x00\x91\x02\x92\x02\xc9\x00\xf2\x03\x6a\x00\xeb\x00\xb3\x02\xe6\x03\x8d\x00\xf0\x03\x93\x02\xd1\x03\x90\x00\x2a\x02\xd2\x03\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xc9\x03\xe1\x03\xd8\x03\x00\x01\x43\x00\x44\x00\xc8\x03\x45\x00\x46\x00\x84\x04\x47\x00\x48\x00\x49\x00\xbe\x03\x92\x04\x8a\x04\x81\x04\xff\x00\xe6\x00\x7f\x04\x4a\x00\x4b\x00\x4c\x00\xca\x00\x00\x01\x58\x02\x4e\x03\xb0\x01\x7b\x04\x80\x00\xba\x01\x32\x04\x4d\x00\x76\x03\x73\x04\x72\x04\x71\x04\x70\x04\xfe\x03\x81\x00\x9c\x00\x9d\x00\x82\x00\xbb\x01\xbc\x01\xbd\x01\xbe\x01\x83\x00\xfc\x03\xfc\x03\x9e\x00\x71\x00\xff\x00\x48\x04\x72\x00\x73\x00\x42\x04\x3d\x04\x39\x04\x38\x04\x36\x04\xf9\x04\x35\x04\x4d\x01\x33\x04\x12\x03\x34\x04\x89\x00\x8a\x00\xd7\x04\xdd\x04\x8c\x00\x8d\x00\x32\x04\xdc\x04\xd8\x04\xd1\x04\x41\x01\xcd\x00\x9f\x00\x0f\x00\xce\x00\xcc\x04\x00\x01\xf4\x04\xfc\x03\xb6\x04\x11\x00\xad\x04\x7b\x00\x7c\x00\xac\x04\xa2\x04\xa0\x00\x14\x01\x11\x05\x23\x05\x18\x05\x16\x05\xed\x00\xee\x00\xef\x00\xf0\x00\x10\x05\x06\x05\x0f\x05\xe8\x00\xe9\x00\x91\x02\xea\x03\x8b\x01\x71\x00\x05\x05\xeb\x00\x72\x00\x73\x00\x8d\x00\x5c\x05\x93\x02\x04\x05\x90\x00\x02\x05\x37\x00\x92\x00\x93\x00\x94\x00\x95\x00\x94\x02\x95\x02\x96\x02\xda\x02\x01\x05\x00\x05\x50\x01\x53\x05\x31\x01\x3d\x00\x3e\x00\x3f\x00\x8c\x01\x0f\x00\x10\x00\xff\x04\xe7\x04\x59\x05\x37\x00\x52\x05\x11\x00\x4c\x05\x7b\x00\x7c\x00\x43\x03\x3c\x05\xda\x02\x00\x01\x27\x05\x3d\x05\x38\x05\x31\x01\x3d\x00\x3e\x00\x3f\x00\x2f\x05\x6c\x05\x6f\x05\x65\x05\x2e\x05\x2d\x05\x61\x05\x70\x05\x9c\x00\x9d\x00\xbe\x03\x57\xfe\x5c\x05\xfe\x03\x81\x05\x40\x00\x37\x00\xfc\x03\x9e\x00\x71\x00\xff\x00\xb7\x03\x72\x00\x73\x00\xda\x02\x7c\x05\xbe\x03\x41\x00\x88\x05\x31\x01\x3d\x00\x3e\x00\x3f\x00\x87\x05\x85\x05\xfc\x03\x82\x05\x8a\x05\x40\x00\x04\x01\xc0\x01\xb1\x01\xa9\x01\xa5\x01\x4d\x01\x85\x01\xcd\x00\x9f\x00\x0f\x00\xce\x00\x41\x00\x7a\x01\x36\x01\x2c\x01\x12\x01\x11\x00\x04\x03\x7b\x00\x7c\x00\xf9\x02\xfc\x02\xa0\x00\x00\x03\xf3\x02\xe5\x02\xdf\x02\x03\x03\xed\x00\xee\x00\xef\x00\xf0\x00\x40\x00\xba\x02\x02\x03\xcb\x02\xac\x02\xa0\x02\xd5\x01\x73\x02\x16\x02\xfe\x01\xbb\x03\x61\x02\x41\x00\xfb\x01\x03\x02\xba\x03\x09\x03\x43\x00\x44\x00\xb9\x03\x45\x00\x46\x00\x54\x02\x47\x00\x48\x00\x49\x00\x9f\x03\xa6\x03\x41\x03\x51\x03\x46\x03\x51\x03\x56\x02\x4a\x00\x4b\x00\x4c\x00\x3f\x03\x37\x00\x81\x03\x77\x03\x43\x00\x44\x00\x76\x03\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\xbb\x02\x7b\x03\x3d\x00\x3e\x00\x3f\x00\x3d\x03\x35\x03\x4a\x00\x4b\x00\x4c\x00\x25\x03\x1d\x03\x1b\x03\x1a\x03\x18\x03\x10\x03\x0f\x03\x0c\x03\x30\x04\x4d\x00\x4a\x05\x2f\x04\x2c\x04\x2e\x04\x43\x00\x44\x00\x2d\x04\x45\x00\x46\x00\x2a\x04\x47\x00\x48\x00\x49\x00\x1d\x04\x0f\x04\x12\x04\x0c\x04\x02\x04\x04\x04\x00\x04\x4a\x00\x4b\x00\x4c\x00\x40\x00\xe6\x03\xfc\x03\xdf\x03\xbf\x03\xd8\x03\x7f\x04\xbe\x03\x37\x00\x4d\x00\xbc\x03\x7d\x04\x41\x00\x54\x02\x44\x01\x6d\x04\x45\x01\x46\x04\xe2\x04\x68\x04\xdf\x04\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x51\x04\xbb\x04\x37\x00\xde\x04\x36\x04\xd3\x04\xd1\x04\xcc\x04\x59\x03\xd2\x04\x5a\x03\xcf\x04\xca\x04\xb4\x04\xa2\x04\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x92\x04\x21\x05\xaa\x04\x16\x05\x13\x05\xfa\x04\xba\x04\xf3\x04\xbc\x02\x87\x02\x20\x05\x02\x05\x37\x00\x12\x05\xe5\x04\xea\x04\x46\x02\x88\x02\xbd\x02\x40\x00\x3b\x00\x8a\x02\x53\x05\x49\x05\x59\x05\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x43\x00\x44\x00\x41\x00\x45\x00\x46\x00\x46\x05\x47\x00\x48\x00\x49\x00\x40\x00\x36\x05\x4f\x05\x4e\x05\x66\x05\x35\x05\x65\x05\x4a\x00\x4b\x00\x4c\x00\x7e\x05\x76\x05\x41\x00\x7a\x05\x74\x05\x85\x05\x83\x05\x00\x00\x8a\x05\x4d\x00\x88\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x02\x00\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x41\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\xbf\x02\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x03\x4d\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x8c\x02\x00\x00\x8a\x02\x8d\x02\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x03\x4d\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x8d\x02\x41\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x80\x00\x4c\x01\xac\xfe\x00\x00\x00\x00\xac\xfe\x00\x00\x00\x00\x40\x04\x00\x00\x81\x00\x37\x00\x00\x00\x82\x00\x00\x00\x00\x00\x88\x02\x89\x02\x83\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x01\x8c\x02\x00\x00\x40\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x81\x00\x45\x00\x46\x00\x82\x00\x47\x00\x48\x00\x49\x00\x00\x00\x83\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x63\x01\x00\x00\x00\x00\x4d\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\xd8\x04\x8c\x02\x00\x00\x37\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x8d\x02\x8d\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x83\x03\x00\x00\x96\x00\x97\x00\x48\x05\x84\x03\x4d\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x8d\x02\x00\x00\x8b\x02\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\x40\x05\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x8c\x02\x88\x02\x89\x02\x9c\x00\x9d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x11\x00\x40\x00\x7b\x00\x7c\x00\x37\x00\x00\x00\xa0\x00\x00\x00\x47\x01\x8d\x02\x00\x00\x07\x05\x00\x00\x41\x00\x08\x05\x09\x05\x0a\x05\x00\x00\x00\x00\x0b\x05\x3f\x00\x48\x01\x00\x00\x49\x01\x4a\x01\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x77\x00\x78\x00\x79\x00\x00\x00\x7a\x00\x00\x00\x0c\x05\x7d\x00\x7e\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x40\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x4d\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x05\x0a\x05\x00\x00\x4d\x00\x0b\x05\x3f\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x05\x00\x00\x00\x00\x0b\x05\x3f\x00\x00\x00\x63\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x80\x00\x4c\x01\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x81\x00\x00\x00\x00\x00\x82\x00\x4d\x00\x00\x00\x40\x00\x37\x00\x83\x00\x00\x00\x00\x00\x12\x02\xe3\x03\xbd\x02\x00\x00\x3b\x00\x8a\x02\x0d\x05\x41\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x4d\x01\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x11\x02\xe2\x03\xbd\x02\x00\x00\x3b\x00\x8a\x02\x00\x00\x00\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x80\x00\x00\x00\x3a\x04\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x81\x00\x45\x00\x46\x00\x82\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x83\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x0d\x05\x00\x00\x41\x00\x00\x00\x4d\x01\x00\x00\x4d\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x00\x00\xbf\x02\x00\x00\x37\x00\x00\x00\x0d\x05\x00\x00\xb5\x03\x5b\x04\xbd\x02\x00\x00\x3b\x00\x8a\x02\x00\x00\x00\x00\x00\x00\xbe\x02\x3d\x00\x3e\x00\x3f\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\xbf\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x41\x00\x00\x00\xb7\x04\x00\x00\x31\x03\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\xb8\x04\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\xb7\x04\x00\x00\x31\x03\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\xbf\x02\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x3e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x41\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x80\x00\xf8\x04\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x80\x00\x00\x00\x00\x00\x81\x00\x00\x00\x40\x00\x82\x00\x00\x00\x00\x00\x4d\x00\x81\x00\x83\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x41\x00\x83\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x01\x8c\x02\x00\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x4d\x01\x8c\x00\x8d\x00\x00\x00\x89\x00\x8a\x00\x00\x00\x00\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x00\x00\x00\x00\x32\x03\x00\x00\x31\x03\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x30\x03\x00\x00\x31\x03\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x14\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x03\x89\x02\x41\x00\x00\x00\x8a\x02\x00\x00\x15\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\x40\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x47\x01\x00\x00\x24\x00\x00\x00\x00\x00\x41\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xb7\x02\x00\x00\x49\x01\x4a\x01\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x76\x00\x00\x00\x77\x00\x78\x00\x79\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x7d\x00\x7e\x00\x41\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x01\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x63\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8d\x02\x8c\x02\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x03\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x04\x89\x02\x00\x00\x00\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x14\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x04\x89\x02\x41\x00\x00\x00\x8a\x02\x00\x00\x15\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\x40\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x47\x01\x00\x00\x24\x00\x00\x00\x00\x00\x41\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x48\x01\x00\x00\x49\x01\x4a\x01\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x76\x00\x00\x00\x77\x00\x78\x00\x79\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x7d\x00\x7e\x00\x41\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x09\x04\x47\x00\x48\x00\x49\x00\x00\x00\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x63\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8d\x02\x8c\x02\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x04\x89\x02\x00\x00\x4d\x00\x8a\x02\x00\x00\x00\x00\x00\x00\x8b\x02\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x2e\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\xd2\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x40\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xd3\x01\xd4\x01\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\xd7\x01\x00\x00\x39\x00\x8c\x02\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x2f\x02\x79\x00\x4d\x00\x7a\x00\x00\x00\x00\x00\xc2\x01\x7e\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\xd5\x01\x47\x00\xd8\x01\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\xd7\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\xd9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xd5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x37\x00\x41\x00\x13\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x14\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x9e\x02\x00\x00\x00\x00\x00\x00\x40\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x42\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x41\x00\x47\x00\xd8\x01\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x5f\x05\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\xd9\x01\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4a\x00\x4b\x00\x4c\x00\x0c\x02\x0d\x02\x7a\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x0e\x02\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x0b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x03\x00\x00\x00\x00\xf0\x03\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x03\x40\x00\x00\x00\xee\x03\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x03\x40\x00\x00\x00\xb0\x04\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x02\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x46\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\xce\x02\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x38\x02\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xb2\x03\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xb1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\xaf\x03\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xae\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x02\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\xc9\x03\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x14\x04\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\xdc\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x88\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x43\x05\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x10\x02\x37\x00\x00\x00\x14\x04\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x11\x04\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x0a\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\xf6\x03\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\xc3\x03\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x42\x04\x37\x00\x00\x00\xeb\x04\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\x0f\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x45\x05\x37\x00\x00\x00\x00\x00\x00\x00\x12\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\x11\x02\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\xb5\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\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\x41\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x37\x00\x00\x00\x00\x00\x00\x00\xc4\x03\x00\x00\x3a\x00\x00\x00\x3b\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3c\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\x37\x00\x00\x00\x00\x00\x00\x00\xe7\x04\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x04\x40\x00\xb2\x04\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x3f\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\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x02\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\xcf\x02\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x42\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x43\x00\x44\x00\x40\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\xcd\x02\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x13\x02\x47\x00\x48\x00\x49\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x48\x03\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x4d\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\x37\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xff\x03\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\xe4\x03\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x41\x00\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x4d\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x6e\x04\x47\x00\x48\x00\x49\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x4d\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x43\x04\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x04\x00\x00\x00\x00\x41\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\xf6\x04\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x39\x05\x00\x00\x00\x00\x00\x00\x00\x00\x31\x01\x3d\x00\x3e\x00\x3f\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x40\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xee\x01\x3f\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x40\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x4d\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x4d\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x44\x00\x00\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x00\x00\x05\x02\xa3\x00\x13\x00\xa4\x00\x00\x00\x4a\x00\x4b\x00\x4c\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x02\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x9a\x03\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\xf6\x00\xd3\x00\x00\x00\xf7\x00\x00\x00\x15\x00\x00\x00\xf8\x00\x00\x00\x16\x00\xf9\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\xfb\x00\x00\x00\xd8\x00\x00\x00\xfc\x00\xfd\x00\x00\x00\x00\x00\xfe\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x57\x04\x58\x04\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x59\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x4e\x04\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\xf7\x00\x00\x00\x15\x00\x00\x00\x4f\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x57\x04\x58\x04\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x59\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x4e\x04\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\x00\x00\x00\xf7\x00\x00\x00\x15\x00\x00\x00\x4f\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x62\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x63\x01\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x95\x01\xb6\x00\x00\x00\x00\x00\x63\x01\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x62\x01\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x63\x01\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xfa\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xff\x00\x00\x01\x01\x01\x02\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x00\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x3c\x02\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x23\x02\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x3f\x02\xb6\x00\x00\x00\x00\x00\x23\x02\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x9a\x01\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\xb3\x02\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x23\x02\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\x00\x00\xd8\xfd\x00\x00\xd8\xfd\x00\x00\xd8\xfd\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\x00\x00\xd8\xfd\x00\x00\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd8\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\x00\x00\xd7\xfd\x00\x00\xd7\xfd\x00\x00\xd7\xfd\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\x00\x00\xd7\xfd\x00\x00\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xd7\xfd\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\x80\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x64\x01\xb7\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\xd0\x00\xd1\x00\xd2\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xd4\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\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\xb0\x00\xb1\x00\xb2\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\xdb\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\xb0\x01\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x01\x00\x00\x00\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\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x03\x00\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x9a\x03\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\xaa\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x90\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x9a\x03\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\xaa\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x15\x00\x90\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\xdc\x03\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\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\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x00\x00\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\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x00\x00\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\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\xa3\x00\x13\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x14\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\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\xa8\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb2\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\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\xa3\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\xb6\x00\x86\x03\x00\x00\x00\x00\x00\x00\xb7\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\xa3\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x2c\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\x2a\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\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\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\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x6a\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\x4f\x00\x13\x00\x00\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x00\x00\xc7\x00\x14\x00\x6d\x00\xc8\x00\xc9\x00\x6e\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x63\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\xdc\x01\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x01\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x63\x01\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x02\x58\x00\x59\x00\x33\x02\x00\x00\x00\x00\x00\x00\x00\x00\x34\x02\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x62\x01\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x01\x61\x00\x62\x00\x63\x00\x64\x00\x35\x02\x36\x02\x00\x00\x67\x00\x68\x00\x37\x02\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\xba\x04\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\xde\x01\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x34\x01\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\x35\x01\x36\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\xc8\x04\x00\x00\x6e\x00\x6f\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\xc9\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x8f\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x04\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x04\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x45\x05\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xfe\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x5c\x03\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x5c\x03\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x4f\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x15\x00\x00\x00\x00\x00\x00\x00\xdc\x02\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x4f\x00\x13\x00\x6b\x00\x6c\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\x6d\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\x00\x00\x00\x13\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x14\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x2a\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x01\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x2c\x00\x6e\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x2e\x03\x17\x00\x18\x00\x19\x00\x2b\x03\x2c\x03\x2d\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x2e\x03\x13\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x14\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x2e\x03\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\xa8\x04\x2a\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\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x0e\x02\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\xc1\x02\xc2\x02\x0e\x02\xc3\x02\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x4e\x03\xc2\x02\x00\x00\xc3\x02\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x02\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\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\x7b\x00\x7c\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\x7b\x00\x7c\x00\xc4\x02\x00\x00\xa0\x00\x00\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xc4\x02\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x01\x53\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x59\x01\x95\x01\x5b\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x5c\x01\x7e\x00\xa0\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\xa1\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x01\x53\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x59\x01\x5a\x01\x5b\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x5c\x01\x7e\x00\xa0\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\xa1\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x01\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x00\x00\x93\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\xa1\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x01\x00\x00\x00\x00\x00\x00\x97\x01\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x02\x00\x00\x00\x00\x6d\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x02\x00\x00\x00\x00\x86\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x88\x03\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x50\x01\x51\x01\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x96\x00\x97\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x54\x01\x00\x00\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\x01\x56\x01\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x58\x01\x91\x01\x00\x00\x92\x01\x11\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\xa0\x00\x00\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\xa1\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\x8a\x03\x8b\x03\x8c\x03\x8d\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\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x94\x03\x95\x03\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x77\x04\x8c\x03\x8d\x03\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x98\x03\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x03\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x03\x01\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x9a\x00\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x5c\x02\x00\x00\x00\x00\x5b\x02\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x5a\x02\x00\x00\x00\x00\x5b\x02\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x51\x02\x52\x02\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x02\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x9a\x03\x95\x03\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x49\x03\x52\x02\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x02\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\xd2\x03\x95\x03\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x8d\x00\xab\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\xac\x01\xad\x01\xae\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x03\x9b\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x75\x04\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x04\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x03\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x7b\x04\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x20\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdb\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x1f\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdd\x00\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xb8\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xb2\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x8a\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x84\x01\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x4d\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x44\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x43\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x42\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x41\x02\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xa1\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xa0\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x90\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x4a\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xe9\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xda\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xd9\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xce\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xcc\x03\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x7c\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x74\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x5a\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xdd\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xaf\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xae\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\xad\x04\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x11\x05\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x8d\x00\x38\x05\x8f\x00\x00\x00\x90\x00\x00\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\xa1\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\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\xa1\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x13\x00\x85\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x87\x00\x00\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x2d\x00\x8b\x00\x8c\x00\x8d\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\xb1\x02\x13\x00\x00\x00\xce\x01\x00\x00\xcf\x01\x00\x00\x86\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\xd0\x01\x00\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x00\x00\x8b\x00\x15\x00\x8d\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\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x04\x00\x00\x00\x00\x15\x00\x00\x00\x9e\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\x9f\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x9d\x04\x00\x00\x00\x00\x15\x00\x00\x00\x9e\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\x9f\x04\xa0\x04\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa1\x04\x00\x00\x13\x00\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\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\x00\x00\x24\x00\x00\x00\x00\x00\x13\x00\xa0\x04\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x9e\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\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x84\x00\x13\x00\x8e\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\x00\x00\x00\x00\x00\x2c\x05\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\xa0\x04\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\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\x2a\x00\x13\x00\xce\x01\x00\x00\xcf\x01\x00\x00\x86\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x2d\x00\x8b\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\x2a\x00\x13\x00\x80\x01\x00\x00\x81\x01\x00\x00\x82\x01\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x88\x00\x00\x00\x00\x00\x00\x00\x8b\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\x2a\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\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x4d\x02\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\x2b\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\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\x2a\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\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\x81\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x84\x00\x00\x00\x6d\x01\x62\x01\x86\x00\x00\x00\x00\x00\x14\x00\x00\x00\x63\x01\x00\x00\x00\x00\x2c\x00\x88\x00\x89\x00\x8a\x00\x1b\x01\x00\x00\x00\x00\x15\x00\x00\x00\x1c\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x84\x00\x00\x00\x1d\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x88\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\x2a\x00\x14\x00\x84\x00\x00\x00\x6d\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x88\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\x2a\x00\x14\x00\x84\x00\x00\x00\x2c\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x88\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\x2a\x00\x14\x00\x84\x00\x00\x00\x1d\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x88\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\x2a\x00\x14\x00\x84\x00\x00\x00\x6d\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x88\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\x2a\x00\x14\x00\x84\x00\x00\x00\x1d\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x88\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\x28\x00\x29\x00\x2a\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\x2c\x00\x88\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\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x0d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\xff\x00\x00\x00\x00\x00\x00\x05\xff\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\xec\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\xaf\x02\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\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\x13\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\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\x2a\x00\x14\x00\x00\x00\x00\x00\x23\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\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\x2a\x00\x14\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x2a\x00\x00\x00\x00\x00\x8d\x00\x23\x04\x89\x01\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x2c\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xb4\x02\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\xed\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x9d\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\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\x7b\x00\x7c\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\x7b\x00\x7c\x00\x00\x00\x8d\x00\xa0\x00\x23\x04\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xc9\x04\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\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\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x9d\x01\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x94\x00\x95\x00\x00\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\x64\x02\x65\x02\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\x64\x02\x93\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\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\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x9f\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x9d\x01\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x01\x93\x00\x94\x00\x95\x00\x00\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\x9e\x01\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xb6\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xa8\x01\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9b\x01\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9a\x01\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x02\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xfd\x02\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xb6\x01\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x02\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x14\x03\x94\x00\x95\x00\x00\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\x7b\x00\x7c\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\x7b\x00\x7c\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\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\xc5\x01\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x01\x00\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\x7b\x00\x7c\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x82\x01\x00\x00\x96\x00\x97\x00\x00\x00\x00\x00\x00\x00\x83\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x83\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\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\x71\x00\x00\x00\x00\x00\x72\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x01\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7b\x00\x7c\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"#  happyReduceArr = Happy_Data_Array.array (13, 826) [ 	(13 , happyReduce_13),@@ -3188,7 +3189,7 @@ 	(826 , happyReduce_826) 	] -happy_n_terms = 152 :: Int+happy_n_terms = 150 :: Int happy_n_nonterms = 315 :: Int  happyReduce_13 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )@@ -8247,7 +8248,7 @@                                         -- a FunBind or PatBind back from checkValDef. See Note                                         -- [FunBind vs PatBind]                                         case r of {-                                          (FunBind _ n _ _ _) ->+                                          (FunBind _ n _ _) ->                                                 amsL l (mj AnnFunId n:(fst happy_var_2)) >> return () ;                                           (PatBind _ (L lh _lhs) _rhs _) ->                                                 amsL lh (fst happy_var_2) >> return () } ;@@ -8597,7 +8598,7 @@ 		 (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)+                            in sL1 happy_var_1 (mkHsQuasiQuote quoterId (mkSrcSpanPs quoteSpan) quote) 	)}  happyReduce_499 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )@@ -8608,7 +8609,7 @@ 		 (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)+                            in sL (getLoc happy_var_1) (mkHsQuasiQuote quoterId (mkSrcSpanPs quoteSpan) quote) 	)}  happyReduce_500 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )@@ -12087,7 +12088,7 @@ 	= (lexer True)(\tk ->  	let cont i = happyDoAction i tk action sts stk in 	case tk of {-	L _ ITeof -> happyDoAction 151# tk action sts stk;+	L _ ITeof -> happyDoAction 149# tk action sts stk; 	L _ ITunderscore -> cont 1#; 	L _ ITas -> cont 2#; 	L _ ITcase -> cont 3#;@@ -12190,58 +12191,56 @@ 	L _ ITvccurly -> cont 100#; 	L _ ITobrack -> cont 101#; 	L _ ITcbrack -> cont 102#;-	L _ ITopabrack -> cont 103#;-	L _ ITcpabrack -> cont 104#;-	L _ IToparen -> cont 105#;-	L _ ITcparen -> cont 106#;-	L _ IToubxparen -> cont 107#;-	L _ ITcubxparen -> cont 108#;-	L _ (IToparenbar _) -> cont 109#;-	L _ (ITcparenbar _) -> cont 110#;-	L _ ITsemi -> cont 111#;-	L _ ITcomma -> cont 112#;-	L _ ITbackquote -> cont 113#;-	L _ ITsimpleQuote -> cont 114#;-	L _ (ITvarid    _) -> cont 115#;-	L _ (ITconid    _) -> cont 116#;-	L _ (ITvarsym   _) -> cont 117#;-	L _ (ITconsym   _) -> cont 118#;-	L _ (ITqvarid   _) -> cont 119#;-	L _ (ITqconid   _) -> cont 120#;-	L _ (ITqvarsym  _) -> cont 121#;-	L _ (ITqconsym  _) -> cont 122#;-	L _ (ITdupipvarid   _) -> cont 123#;-	L _ (ITlabelvarid   _) -> cont 124#;-	L _ (ITchar   _ _) -> cont 125#;-	L _ (ITstring _ _) -> cont 126#;-	L _ (ITinteger _) -> cont 127#;-	L _ (ITrational _) -> cont 128#;-	L _ (ITprimchar   _ _) -> cont 129#;-	L _ (ITprimstring _ _) -> cont 130#;-	L _ (ITprimint    _ _) -> cont 131#;-	L _ (ITprimword   _ _) -> cont 132#;-	L _ (ITprimfloat  _) -> cont 133#;-	L _ (ITprimdouble _) -> cont 134#;-	L _ (ITdocCommentNext _) -> cont 135#;-	L _ (ITdocCommentPrev _) -> cont 136#;-	L _ (ITdocCommentNamed _) -> cont 137#;-	L _ (ITdocSection _ _) -> cont 138#;-	L _ (ITopenExpQuote _ _) -> cont 139#;-	L _ ITopenPatQuote -> cont 140#;-	L _ ITopenTypQuote -> cont 141#;-	L _ ITopenDecQuote -> cont 142#;-	L _ (ITcloseQuote _) -> cont 143#;-	L _ (ITopenTExpQuote _) -> cont 144#;-	L _ ITcloseTExpQuote -> cont 145#;-	L _ ITdollar -> cont 146#;-	L _ ITdollardollar -> cont 147#;-	L _ ITtyQuote -> cont 148#;-	L _ (ITquasiQuote _) -> cont 149#;-	L _ (ITqQuasiQuote _) -> cont 150#;+	L _ IToparen -> cont 103#;+	L _ ITcparen -> cont 104#;+	L _ IToubxparen -> cont 105#;+	L _ ITcubxparen -> cont 106#;+	L _ (IToparenbar _) -> cont 107#;+	L _ (ITcparenbar _) -> cont 108#;+	L _ ITsemi -> cont 109#;+	L _ ITcomma -> cont 110#;+	L _ ITbackquote -> cont 111#;+	L _ ITsimpleQuote -> cont 112#;+	L _ (ITvarid    _) -> cont 113#;+	L _ (ITconid    _) -> cont 114#;+	L _ (ITvarsym   _) -> cont 115#;+	L _ (ITconsym   _) -> cont 116#;+	L _ (ITqvarid   _) -> cont 117#;+	L _ (ITqconid   _) -> cont 118#;+	L _ (ITqvarsym  _) -> cont 119#;+	L _ (ITqconsym  _) -> cont 120#;+	L _ (ITdupipvarid   _) -> cont 121#;+	L _ (ITlabelvarid   _) -> cont 122#;+	L _ (ITchar   _ _) -> cont 123#;+	L _ (ITstring _ _) -> cont 124#;+	L _ (ITinteger _) -> cont 125#;+	L _ (ITrational _) -> cont 126#;+	L _ (ITprimchar   _ _) -> cont 127#;+	L _ (ITprimstring _ _) -> cont 128#;+	L _ (ITprimint    _ _) -> cont 129#;+	L _ (ITprimword   _ _) -> cont 130#;+	L _ (ITprimfloat  _) -> cont 131#;+	L _ (ITprimdouble _) -> cont 132#;+	L _ (ITdocCommentNext _) -> cont 133#;+	L _ (ITdocCommentPrev _) -> cont 134#;+	L _ (ITdocCommentNamed _) -> cont 135#;+	L _ (ITdocSection _ _) -> cont 136#;+	L _ (ITopenExpQuote _ _) -> cont 137#;+	L _ ITopenPatQuote -> cont 138#;+	L _ ITopenTypQuote -> cont 139#;+	L _ ITopenDecQuote -> cont 140#;+	L _ (ITcloseQuote _) -> cont 141#;+	L _ (ITopenTExpQuote _) -> cont 142#;+	L _ ITcloseTExpQuote -> cont 143#;+	L _ ITdollar -> cont 144#;+	L _ ITdollardollar -> cont 145#;+	L _ ITtyQuote -> cont 146#;+	L _ (ITquasiQuote _) -> cont 147#;+	L _ (ITqQuasiQuote _) -> cont 148#; 	_ -> happyError' (tk, []) 	}) -happyError_ explist 151# tk = happyError' (tk, explist)+happyError_ explist 149# tk = happyError' (tk, explist) happyError_ explist _ tk = happyError' (tk, explist)  happyThen :: () => P a -> (a -> P b) -> P b

ghc-lib/stage0/compiler/build/primop-data-decl.hs-incl view

@@ -465,6 +465,9 @@    | CasMutVarOp    | CatchOp    | RaiseOp+   | RaiseDivZeroOp+   | RaiseUnderflowOp+   | RaiseOverflowOp    | RaiseIOOp    | MaskAsyncExceptionsOp    | MaskUninterruptibleOp

ghc-lib/stage0/compiler/build/primop-has-side-effects.hs-incl view

@@ -156,6 +156,9 @@ primOpHasSideEffects CasMutVarOp = True primOpHasSideEffects CatchOp = True primOpHasSideEffects RaiseOp = True+primOpHasSideEffects RaiseDivZeroOp = True+primOpHasSideEffects RaiseUnderflowOp = True+primOpHasSideEffects RaiseOverflowOp = True primOpHasSideEffects RaiseIOOp = True primOpHasSideEffects MaskAsyncExceptionsOp = True primOpHasSideEffects MaskUninterruptibleOp = True

ghc-lib/stage0/compiler/build/primop-list.hs-incl view

@@ -464,6 +464,9 @@    , CasMutVarOp    , CatchOp    , RaiseOp+   , RaiseDivZeroOp+   , RaiseUnderflowOp+   , RaiseOverflowOp    , RaiseIOOp    , MaskAsyncExceptionsOp    , MaskUninterruptibleOp

ghc-lib/stage0/compiler/build/primop-out-of-line.hs-incl view

@@ -36,6 +36,9 @@ primOpOutOfLine CasMutVarOp = True primOpOutOfLine CatchOp = True primOpOutOfLine RaiseOp = True+primOpOutOfLine RaiseDivZeroOp = True+primOpOutOfLine RaiseUnderflowOp = True+primOpOutOfLine RaiseOverflowOp = True primOpOutOfLine RaiseIOOp = True primOpOutOfLine MaskAsyncExceptionsOp = True primOpOutOfLine MaskUninterruptibleOp = True

ghc-lib/stage0/compiler/build/primop-primop-info.hs-incl view

@@ -464,6 +464,9 @@ primOpInfo CasMutVarOp = mkGenPrimOp (fsLit "casMutVar#")  [deltaTyVar, alphaTyVar] [mkMutVarPrimTy deltaTy alphaTy, alphaTy, alphaTy, mkStatePrimTy deltaTy] ((mkTupleTy Unboxed [mkStatePrimTy deltaTy, intPrimTy, alphaTy])) primOpInfo CatchOp = mkGenPrimOp (fsLit "catch#")  [alphaTyVar, betaTyVar] [(mkVisFunTy (mkStatePrimTy realWorldTy) ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy]))), (mkVisFunTy (betaTy) ((mkVisFunTy (mkStatePrimTy realWorldTy) ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy]))))), mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy])) primOpInfo RaiseOp = mkGenPrimOp (fsLit "raise#")  [betaTyVar, runtimeRep1TyVar, openAlphaTyVar] [betaTy] (openAlphaTy)+primOpInfo RaiseDivZeroOp = mkGenPrimOp (fsLit "raiseDivZero#")  [runtimeRep1TyVar, openAlphaTyVar] [voidPrimTy] (openAlphaTy)+primOpInfo RaiseUnderflowOp = mkGenPrimOp (fsLit "raiseUnderflow#")  [runtimeRep1TyVar, openAlphaTyVar] [voidPrimTy] (openAlphaTy)+primOpInfo RaiseOverflowOp = mkGenPrimOp (fsLit "raiseOverflow#")  [runtimeRep1TyVar, openAlphaTyVar] [voidPrimTy] (openAlphaTy) primOpInfo RaiseIOOp = mkGenPrimOp (fsLit "raiseIO#")  [alphaTyVar, betaTyVar] [alphaTy, mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, betaTy])) primOpInfo MaskAsyncExceptionsOp = mkGenPrimOp (fsLit "maskAsyncExceptions#")  [alphaTyVar] [(mkVisFunTy (mkStatePrimTy realWorldTy) ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy]))), mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy])) primOpInfo MaskUninterruptibleOp = mkGenPrimOp (fsLit "maskUninterruptible#")  [alphaTyVar] [(mkVisFunTy (mkStatePrimTy realWorldTy) ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy]))), mkStatePrimTy realWorldTy] ((mkTupleTy Unboxed [mkStatePrimTy realWorldTy, alphaTy]))

ghc-lib/stage0/compiler/build/primop-strictness.hs-incl view

@@ -1,22 +1,25 @@ primOpStrictness CatchOp =  \ _arity -> mkClosedStrictSig [ lazyApply1Dmd                                                  , lazyApply2Dmd-                                                 , topDmd] topRes -primOpStrictness RaiseOp =  \ _arity -> mkClosedStrictSig [topDmd] botRes -primOpStrictness RaiseIOOp =  \ _arity -> mkClosedStrictSig [topDmd, topDmd] botRes -primOpStrictness MaskAsyncExceptionsOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topRes -primOpStrictness MaskUninterruptibleOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topRes -primOpStrictness UnmaskAsyncExceptionsOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topRes -primOpStrictness AtomicallyOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topRes -primOpStrictness RetryOp =  \ _arity -> mkClosedStrictSig [topDmd] botRes +                                                 , topDmd] topDiv +primOpStrictness RaiseOp =  \ _arity -> mkClosedStrictSig [topDmd] botDiv +primOpStrictness RaiseDivZeroOp =  \ _arity -> mkClosedStrictSig [topDmd] botDiv +primOpStrictness RaiseUnderflowOp =  \ _arity -> mkClosedStrictSig [topDmd] botDiv +primOpStrictness RaiseOverflowOp =  \ _arity -> mkClosedStrictSig [topDmd] botDiv +primOpStrictness RaiseIOOp =  \ _arity -> mkClosedStrictSig [topDmd, topDmd] botDiv +primOpStrictness MaskAsyncExceptionsOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topDiv +primOpStrictness MaskUninterruptibleOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topDiv +primOpStrictness UnmaskAsyncExceptionsOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topDiv +primOpStrictness AtomicallyOp =  \ _arity -> mkClosedStrictSig [strictApply1Dmd,topDmd] topDiv +primOpStrictness RetryOp =  \ _arity -> mkClosedStrictSig [topDmd] botDiv  primOpStrictness CatchRetryOp =  \ _arity -> mkClosedStrictSig [ lazyApply1Dmd                                                  , lazyApply1Dmd-                                                 , topDmd ] topRes +                                                 , topDmd ] topDiv  primOpStrictness CatchSTMOp =  \ _arity -> mkClosedStrictSig [ lazyApply1Dmd                                                  , lazyApply2Dmd-                                                 , topDmd ] topRes -primOpStrictness DataToTagOp =  \ _arity -> mkClosedStrictSig [evalDmd] topRes -primOpStrictness PrefetchValueOp3 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topRes -primOpStrictness PrefetchValueOp2 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topRes -primOpStrictness PrefetchValueOp1 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topRes -primOpStrictness PrefetchValueOp0 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topRes -primOpStrictness _ =  \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes +                                                 , topDmd ] topDiv +primOpStrictness DataToTagOp =  \ _arity -> mkClosedStrictSig [evalDmd] topDiv +primOpStrictness PrefetchValueOp3 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topDiv +primOpStrictness PrefetchValueOp2 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topDiv +primOpStrictness PrefetchValueOp1 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topDiv +primOpStrictness PrefetchValueOp0 =  \ _arity -> mkClosedStrictSig [botDmd, topDmd] topDiv +primOpStrictness _ =  \ arity -> mkClosedStrictSig (replicate arity topDmd) topDiv

ghc-lib/stage0/compiler/build/primop-tag.hs-incl view

@@ -1,1207 +1,1210 @@ maxPrimOpTag :: Int-maxPrimOpTag = 1204-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 Int8Extend = 8-primOpTag Int8Narrow = 9-primOpTag Int8NegOp = 10-primOpTag Int8AddOp = 11-primOpTag Int8SubOp = 12-primOpTag Int8MulOp = 13-primOpTag Int8QuotOp = 14-primOpTag Int8RemOp = 15-primOpTag Int8QuotRemOp = 16-primOpTag Int8EqOp = 17-primOpTag Int8GeOp = 18-primOpTag Int8GtOp = 19-primOpTag Int8LeOp = 20-primOpTag Int8LtOp = 21-primOpTag Int8NeOp = 22-primOpTag Word8Extend = 23-primOpTag Word8Narrow = 24-primOpTag Word8NotOp = 25-primOpTag Word8AddOp = 26-primOpTag Word8SubOp = 27-primOpTag Word8MulOp = 28-primOpTag Word8QuotOp = 29-primOpTag Word8RemOp = 30-primOpTag Word8QuotRemOp = 31-primOpTag Word8EqOp = 32-primOpTag Word8GeOp = 33-primOpTag Word8GtOp = 34-primOpTag Word8LeOp = 35-primOpTag Word8LtOp = 36-primOpTag Word8NeOp = 37-primOpTag Int16Extend = 38-primOpTag Int16Narrow = 39-primOpTag Int16NegOp = 40-primOpTag Int16AddOp = 41-primOpTag Int16SubOp = 42-primOpTag Int16MulOp = 43-primOpTag Int16QuotOp = 44-primOpTag Int16RemOp = 45-primOpTag Int16QuotRemOp = 46-primOpTag Int16EqOp = 47-primOpTag Int16GeOp = 48-primOpTag Int16GtOp = 49-primOpTag Int16LeOp = 50-primOpTag Int16LtOp = 51-primOpTag Int16NeOp = 52-primOpTag Word16Extend = 53-primOpTag Word16Narrow = 54-primOpTag Word16NotOp = 55-primOpTag Word16AddOp = 56-primOpTag Word16SubOp = 57-primOpTag Word16MulOp = 58-primOpTag Word16QuotOp = 59-primOpTag Word16RemOp = 60-primOpTag Word16QuotRemOp = 61-primOpTag Word16EqOp = 62-primOpTag Word16GeOp = 63-primOpTag Word16GtOp = 64-primOpTag Word16LeOp = 65-primOpTag Word16LtOp = 66-primOpTag Word16NeOp = 67-primOpTag IntAddOp = 68-primOpTag IntSubOp = 69-primOpTag IntMulOp = 70-primOpTag IntMul2Op = 71-primOpTag IntMulMayOfloOp = 72-primOpTag IntQuotOp = 73-primOpTag IntRemOp = 74-primOpTag IntQuotRemOp = 75-primOpTag AndIOp = 76-primOpTag OrIOp = 77-primOpTag XorIOp = 78-primOpTag NotIOp = 79-primOpTag IntNegOp = 80-primOpTag IntAddCOp = 81-primOpTag IntSubCOp = 82-primOpTag IntGtOp = 83-primOpTag IntGeOp = 84-primOpTag IntEqOp = 85-primOpTag IntNeOp = 86-primOpTag IntLtOp = 87-primOpTag IntLeOp = 88-primOpTag ChrOp = 89-primOpTag Int2WordOp = 90-primOpTag Int2FloatOp = 91-primOpTag Int2DoubleOp = 92-primOpTag Word2FloatOp = 93-primOpTag Word2DoubleOp = 94-primOpTag ISllOp = 95-primOpTag ISraOp = 96-primOpTag ISrlOp = 97-primOpTag WordAddOp = 98-primOpTag WordAddCOp = 99-primOpTag WordSubCOp = 100-primOpTag WordAdd2Op = 101-primOpTag WordSubOp = 102-primOpTag WordMulOp = 103-primOpTag WordMul2Op = 104-primOpTag WordQuotOp = 105-primOpTag WordRemOp = 106-primOpTag WordQuotRemOp = 107-primOpTag WordQuotRem2Op = 108-primOpTag AndOp = 109-primOpTag OrOp = 110-primOpTag XorOp = 111-primOpTag NotOp = 112-primOpTag SllOp = 113-primOpTag SrlOp = 114-primOpTag Word2IntOp = 115-primOpTag WordGtOp = 116-primOpTag WordGeOp = 117-primOpTag WordEqOp = 118-primOpTag WordNeOp = 119-primOpTag WordLtOp = 120-primOpTag WordLeOp = 121-primOpTag PopCnt8Op = 122-primOpTag PopCnt16Op = 123-primOpTag PopCnt32Op = 124-primOpTag PopCnt64Op = 125-primOpTag PopCntOp = 126-primOpTag Pdep8Op = 127-primOpTag Pdep16Op = 128-primOpTag Pdep32Op = 129-primOpTag Pdep64Op = 130-primOpTag PdepOp = 131-primOpTag Pext8Op = 132-primOpTag Pext16Op = 133-primOpTag Pext32Op = 134-primOpTag Pext64Op = 135-primOpTag PextOp = 136-primOpTag Clz8Op = 137-primOpTag Clz16Op = 138-primOpTag Clz32Op = 139-primOpTag Clz64Op = 140-primOpTag ClzOp = 141-primOpTag Ctz8Op = 142-primOpTag Ctz16Op = 143-primOpTag Ctz32Op = 144-primOpTag Ctz64Op = 145-primOpTag CtzOp = 146-primOpTag BSwap16Op = 147-primOpTag BSwap32Op = 148-primOpTag BSwap64Op = 149-primOpTag BSwapOp = 150-primOpTag BRev8Op = 151-primOpTag BRev16Op = 152-primOpTag BRev32Op = 153-primOpTag BRev64Op = 154-primOpTag BRevOp = 155-primOpTag Narrow8IntOp = 156-primOpTag Narrow16IntOp = 157-primOpTag Narrow32IntOp = 158-primOpTag Narrow8WordOp = 159-primOpTag Narrow16WordOp = 160-primOpTag Narrow32WordOp = 161-primOpTag DoubleGtOp = 162-primOpTag DoubleGeOp = 163-primOpTag DoubleEqOp = 164-primOpTag DoubleNeOp = 165-primOpTag DoubleLtOp = 166-primOpTag DoubleLeOp = 167-primOpTag DoubleAddOp = 168-primOpTag DoubleSubOp = 169-primOpTag DoubleMulOp = 170-primOpTag DoubleDivOp = 171-primOpTag DoubleNegOp = 172-primOpTag DoubleFabsOp = 173-primOpTag Double2IntOp = 174-primOpTag Double2FloatOp = 175-primOpTag DoubleExpOp = 176-primOpTag DoubleExpM1Op = 177-primOpTag DoubleLogOp = 178-primOpTag DoubleLog1POp = 179-primOpTag DoubleSqrtOp = 180-primOpTag DoubleSinOp = 181-primOpTag DoubleCosOp = 182-primOpTag DoubleTanOp = 183-primOpTag DoubleAsinOp = 184-primOpTag DoubleAcosOp = 185-primOpTag DoubleAtanOp = 186-primOpTag DoubleSinhOp = 187-primOpTag DoubleCoshOp = 188-primOpTag DoubleTanhOp = 189-primOpTag DoubleAsinhOp = 190-primOpTag DoubleAcoshOp = 191-primOpTag DoubleAtanhOp = 192-primOpTag DoublePowerOp = 193-primOpTag DoubleDecode_2IntOp = 194-primOpTag DoubleDecode_Int64Op = 195-primOpTag FloatGtOp = 196-primOpTag FloatGeOp = 197-primOpTag FloatEqOp = 198-primOpTag FloatNeOp = 199-primOpTag FloatLtOp = 200-primOpTag FloatLeOp = 201-primOpTag FloatAddOp = 202-primOpTag FloatSubOp = 203-primOpTag FloatMulOp = 204-primOpTag FloatDivOp = 205-primOpTag FloatNegOp = 206-primOpTag FloatFabsOp = 207-primOpTag Float2IntOp = 208-primOpTag FloatExpOp = 209-primOpTag FloatExpM1Op = 210-primOpTag FloatLogOp = 211-primOpTag FloatLog1POp = 212-primOpTag FloatSqrtOp = 213-primOpTag FloatSinOp = 214-primOpTag FloatCosOp = 215-primOpTag FloatTanOp = 216-primOpTag FloatAsinOp = 217-primOpTag FloatAcosOp = 218-primOpTag FloatAtanOp = 219-primOpTag FloatSinhOp = 220-primOpTag FloatCoshOp = 221-primOpTag FloatTanhOp = 222-primOpTag FloatAsinhOp = 223-primOpTag FloatAcoshOp = 224-primOpTag FloatAtanhOp = 225-primOpTag FloatPowerOp = 226-primOpTag Float2DoubleOp = 227-primOpTag FloatDecode_IntOp = 228-primOpTag NewArrayOp = 229-primOpTag SameMutableArrayOp = 230-primOpTag ReadArrayOp = 231-primOpTag WriteArrayOp = 232-primOpTag SizeofArrayOp = 233-primOpTag SizeofMutableArrayOp = 234-primOpTag IndexArrayOp = 235-primOpTag UnsafeFreezeArrayOp = 236-primOpTag UnsafeThawArrayOp = 237-primOpTag CopyArrayOp = 238-primOpTag CopyMutableArrayOp = 239-primOpTag CloneArrayOp = 240-primOpTag CloneMutableArrayOp = 241-primOpTag FreezeArrayOp = 242-primOpTag ThawArrayOp = 243-primOpTag CasArrayOp = 244-primOpTag NewSmallArrayOp = 245-primOpTag SameSmallMutableArrayOp = 246-primOpTag ShrinkSmallMutableArrayOp_Char = 247-primOpTag ReadSmallArrayOp = 248-primOpTag WriteSmallArrayOp = 249-primOpTag SizeofSmallArrayOp = 250-primOpTag SizeofSmallMutableArrayOp = 251-primOpTag GetSizeofSmallMutableArrayOp = 252-primOpTag IndexSmallArrayOp = 253-primOpTag UnsafeFreezeSmallArrayOp = 254-primOpTag UnsafeThawSmallArrayOp = 255-primOpTag CopySmallArrayOp = 256-primOpTag CopySmallMutableArrayOp = 257-primOpTag CloneSmallArrayOp = 258-primOpTag CloneSmallMutableArrayOp = 259-primOpTag FreezeSmallArrayOp = 260-primOpTag ThawSmallArrayOp = 261-primOpTag CasSmallArrayOp = 262-primOpTag NewByteArrayOp_Char = 263-primOpTag NewPinnedByteArrayOp_Char = 264-primOpTag NewAlignedPinnedByteArrayOp_Char = 265-primOpTag MutableByteArrayIsPinnedOp = 266-primOpTag ByteArrayIsPinnedOp = 267-primOpTag ByteArrayContents_Char = 268-primOpTag SameMutableByteArrayOp = 269-primOpTag ShrinkMutableByteArrayOp_Char = 270-primOpTag ResizeMutableByteArrayOp_Char = 271-primOpTag UnsafeFreezeByteArrayOp = 272-primOpTag SizeofByteArrayOp = 273-primOpTag SizeofMutableByteArrayOp = 274-primOpTag GetSizeofMutableByteArrayOp = 275-primOpTag IndexByteArrayOp_Char = 276-primOpTag IndexByteArrayOp_WideChar = 277-primOpTag IndexByteArrayOp_Int = 278-primOpTag IndexByteArrayOp_Word = 279-primOpTag IndexByteArrayOp_Addr = 280-primOpTag IndexByteArrayOp_Float = 281-primOpTag IndexByteArrayOp_Double = 282-primOpTag IndexByteArrayOp_StablePtr = 283-primOpTag IndexByteArrayOp_Int8 = 284-primOpTag IndexByteArrayOp_Int16 = 285-primOpTag IndexByteArrayOp_Int32 = 286-primOpTag IndexByteArrayOp_Int64 = 287-primOpTag IndexByteArrayOp_Word8 = 288-primOpTag IndexByteArrayOp_Word16 = 289-primOpTag IndexByteArrayOp_Word32 = 290-primOpTag IndexByteArrayOp_Word64 = 291-primOpTag IndexByteArrayOp_Word8AsChar = 292-primOpTag IndexByteArrayOp_Word8AsWideChar = 293-primOpTag IndexByteArrayOp_Word8AsAddr = 294-primOpTag IndexByteArrayOp_Word8AsFloat = 295-primOpTag IndexByteArrayOp_Word8AsDouble = 296-primOpTag IndexByteArrayOp_Word8AsStablePtr = 297-primOpTag IndexByteArrayOp_Word8AsInt16 = 298-primOpTag IndexByteArrayOp_Word8AsInt32 = 299-primOpTag IndexByteArrayOp_Word8AsInt64 = 300-primOpTag IndexByteArrayOp_Word8AsInt = 301-primOpTag IndexByteArrayOp_Word8AsWord16 = 302-primOpTag IndexByteArrayOp_Word8AsWord32 = 303-primOpTag IndexByteArrayOp_Word8AsWord64 = 304-primOpTag IndexByteArrayOp_Word8AsWord = 305-primOpTag ReadByteArrayOp_Char = 306-primOpTag ReadByteArrayOp_WideChar = 307-primOpTag ReadByteArrayOp_Int = 308-primOpTag ReadByteArrayOp_Word = 309-primOpTag ReadByteArrayOp_Addr = 310-primOpTag ReadByteArrayOp_Float = 311-primOpTag ReadByteArrayOp_Double = 312-primOpTag ReadByteArrayOp_StablePtr = 313-primOpTag ReadByteArrayOp_Int8 = 314-primOpTag ReadByteArrayOp_Int16 = 315-primOpTag ReadByteArrayOp_Int32 = 316-primOpTag ReadByteArrayOp_Int64 = 317-primOpTag ReadByteArrayOp_Word8 = 318-primOpTag ReadByteArrayOp_Word16 = 319-primOpTag ReadByteArrayOp_Word32 = 320-primOpTag ReadByteArrayOp_Word64 = 321-primOpTag ReadByteArrayOp_Word8AsChar = 322-primOpTag ReadByteArrayOp_Word8AsWideChar = 323-primOpTag ReadByteArrayOp_Word8AsAddr = 324-primOpTag ReadByteArrayOp_Word8AsFloat = 325-primOpTag ReadByteArrayOp_Word8AsDouble = 326-primOpTag ReadByteArrayOp_Word8AsStablePtr = 327-primOpTag ReadByteArrayOp_Word8AsInt16 = 328-primOpTag ReadByteArrayOp_Word8AsInt32 = 329-primOpTag ReadByteArrayOp_Word8AsInt64 = 330-primOpTag ReadByteArrayOp_Word8AsInt = 331-primOpTag ReadByteArrayOp_Word8AsWord16 = 332-primOpTag ReadByteArrayOp_Word8AsWord32 = 333-primOpTag ReadByteArrayOp_Word8AsWord64 = 334-primOpTag ReadByteArrayOp_Word8AsWord = 335-primOpTag WriteByteArrayOp_Char = 336-primOpTag WriteByteArrayOp_WideChar = 337-primOpTag WriteByteArrayOp_Int = 338-primOpTag WriteByteArrayOp_Word = 339-primOpTag WriteByteArrayOp_Addr = 340-primOpTag WriteByteArrayOp_Float = 341-primOpTag WriteByteArrayOp_Double = 342-primOpTag WriteByteArrayOp_StablePtr = 343-primOpTag WriteByteArrayOp_Int8 = 344-primOpTag WriteByteArrayOp_Int16 = 345-primOpTag WriteByteArrayOp_Int32 = 346-primOpTag WriteByteArrayOp_Int64 = 347-primOpTag WriteByteArrayOp_Word8 = 348-primOpTag WriteByteArrayOp_Word16 = 349-primOpTag WriteByteArrayOp_Word32 = 350-primOpTag WriteByteArrayOp_Word64 = 351-primOpTag WriteByteArrayOp_Word8AsChar = 352-primOpTag WriteByteArrayOp_Word8AsWideChar = 353-primOpTag WriteByteArrayOp_Word8AsAddr = 354-primOpTag WriteByteArrayOp_Word8AsFloat = 355-primOpTag WriteByteArrayOp_Word8AsDouble = 356-primOpTag WriteByteArrayOp_Word8AsStablePtr = 357-primOpTag WriteByteArrayOp_Word8AsInt16 = 358-primOpTag WriteByteArrayOp_Word8AsInt32 = 359-primOpTag WriteByteArrayOp_Word8AsInt64 = 360-primOpTag WriteByteArrayOp_Word8AsInt = 361-primOpTag WriteByteArrayOp_Word8AsWord16 = 362-primOpTag WriteByteArrayOp_Word8AsWord32 = 363-primOpTag WriteByteArrayOp_Word8AsWord64 = 364-primOpTag WriteByteArrayOp_Word8AsWord = 365-primOpTag CompareByteArraysOp = 366-primOpTag CopyByteArrayOp = 367-primOpTag CopyMutableByteArrayOp = 368-primOpTag CopyByteArrayToAddrOp = 369-primOpTag CopyMutableByteArrayToAddrOp = 370-primOpTag CopyAddrToByteArrayOp = 371-primOpTag SetByteArrayOp = 372-primOpTag AtomicReadByteArrayOp_Int = 373-primOpTag AtomicWriteByteArrayOp_Int = 374-primOpTag CasByteArrayOp_Int = 375-primOpTag FetchAddByteArrayOp_Int = 376-primOpTag FetchSubByteArrayOp_Int = 377-primOpTag FetchAndByteArrayOp_Int = 378-primOpTag FetchNandByteArrayOp_Int = 379-primOpTag FetchOrByteArrayOp_Int = 380-primOpTag FetchXorByteArrayOp_Int = 381-primOpTag NewArrayArrayOp = 382-primOpTag SameMutableArrayArrayOp = 383-primOpTag UnsafeFreezeArrayArrayOp = 384-primOpTag SizeofArrayArrayOp = 385-primOpTag SizeofMutableArrayArrayOp = 386-primOpTag IndexArrayArrayOp_ByteArray = 387-primOpTag IndexArrayArrayOp_ArrayArray = 388-primOpTag ReadArrayArrayOp_ByteArray = 389-primOpTag ReadArrayArrayOp_MutableByteArray = 390-primOpTag ReadArrayArrayOp_ArrayArray = 391-primOpTag ReadArrayArrayOp_MutableArrayArray = 392-primOpTag WriteArrayArrayOp_ByteArray = 393-primOpTag WriteArrayArrayOp_MutableByteArray = 394-primOpTag WriteArrayArrayOp_ArrayArray = 395-primOpTag WriteArrayArrayOp_MutableArrayArray = 396-primOpTag CopyArrayArrayOp = 397-primOpTag CopyMutableArrayArrayOp = 398-primOpTag AddrAddOp = 399-primOpTag AddrSubOp = 400-primOpTag AddrRemOp = 401-primOpTag Addr2IntOp = 402-primOpTag Int2AddrOp = 403-primOpTag AddrGtOp = 404-primOpTag AddrGeOp = 405-primOpTag AddrEqOp = 406-primOpTag AddrNeOp = 407-primOpTag AddrLtOp = 408-primOpTag AddrLeOp = 409-primOpTag IndexOffAddrOp_Char = 410-primOpTag IndexOffAddrOp_WideChar = 411-primOpTag IndexOffAddrOp_Int = 412-primOpTag IndexOffAddrOp_Word = 413-primOpTag IndexOffAddrOp_Addr = 414-primOpTag IndexOffAddrOp_Float = 415-primOpTag IndexOffAddrOp_Double = 416-primOpTag IndexOffAddrOp_StablePtr = 417-primOpTag IndexOffAddrOp_Int8 = 418-primOpTag IndexOffAddrOp_Int16 = 419-primOpTag IndexOffAddrOp_Int32 = 420-primOpTag IndexOffAddrOp_Int64 = 421-primOpTag IndexOffAddrOp_Word8 = 422-primOpTag IndexOffAddrOp_Word16 = 423-primOpTag IndexOffAddrOp_Word32 = 424-primOpTag IndexOffAddrOp_Word64 = 425-primOpTag ReadOffAddrOp_Char = 426-primOpTag ReadOffAddrOp_WideChar = 427-primOpTag ReadOffAddrOp_Int = 428-primOpTag ReadOffAddrOp_Word = 429-primOpTag ReadOffAddrOp_Addr = 430-primOpTag ReadOffAddrOp_Float = 431-primOpTag ReadOffAddrOp_Double = 432-primOpTag ReadOffAddrOp_StablePtr = 433-primOpTag ReadOffAddrOp_Int8 = 434-primOpTag ReadOffAddrOp_Int16 = 435-primOpTag ReadOffAddrOp_Int32 = 436-primOpTag ReadOffAddrOp_Int64 = 437-primOpTag ReadOffAddrOp_Word8 = 438-primOpTag ReadOffAddrOp_Word16 = 439-primOpTag ReadOffAddrOp_Word32 = 440-primOpTag ReadOffAddrOp_Word64 = 441-primOpTag WriteOffAddrOp_Char = 442-primOpTag WriteOffAddrOp_WideChar = 443-primOpTag WriteOffAddrOp_Int = 444-primOpTag WriteOffAddrOp_Word = 445-primOpTag WriteOffAddrOp_Addr = 446-primOpTag WriteOffAddrOp_Float = 447-primOpTag WriteOffAddrOp_Double = 448-primOpTag WriteOffAddrOp_StablePtr = 449-primOpTag WriteOffAddrOp_Int8 = 450-primOpTag WriteOffAddrOp_Int16 = 451-primOpTag WriteOffAddrOp_Int32 = 452-primOpTag WriteOffAddrOp_Int64 = 453-primOpTag WriteOffAddrOp_Word8 = 454-primOpTag WriteOffAddrOp_Word16 = 455-primOpTag WriteOffAddrOp_Word32 = 456-primOpTag WriteOffAddrOp_Word64 = 457-primOpTag NewMutVarOp = 458-primOpTag ReadMutVarOp = 459-primOpTag WriteMutVarOp = 460-primOpTag SameMutVarOp = 461-primOpTag AtomicModifyMutVar2Op = 462-primOpTag AtomicModifyMutVar_Op = 463-primOpTag CasMutVarOp = 464-primOpTag CatchOp = 465-primOpTag RaiseOp = 466-primOpTag RaiseIOOp = 467-primOpTag MaskAsyncExceptionsOp = 468-primOpTag MaskUninterruptibleOp = 469-primOpTag UnmaskAsyncExceptionsOp = 470-primOpTag MaskStatus = 471-primOpTag AtomicallyOp = 472-primOpTag RetryOp = 473-primOpTag CatchRetryOp = 474-primOpTag CatchSTMOp = 475-primOpTag NewTVarOp = 476-primOpTag ReadTVarOp = 477-primOpTag ReadTVarIOOp = 478-primOpTag WriteTVarOp = 479-primOpTag SameTVarOp = 480-primOpTag NewMVarOp = 481-primOpTag TakeMVarOp = 482-primOpTag TryTakeMVarOp = 483-primOpTag PutMVarOp = 484-primOpTag TryPutMVarOp = 485-primOpTag ReadMVarOp = 486-primOpTag TryReadMVarOp = 487-primOpTag SameMVarOp = 488-primOpTag IsEmptyMVarOp = 489-primOpTag DelayOp = 490-primOpTag WaitReadOp = 491-primOpTag WaitWriteOp = 492-primOpTag ForkOp = 493-primOpTag ForkOnOp = 494-primOpTag KillThreadOp = 495-primOpTag YieldOp = 496-primOpTag MyThreadIdOp = 497-primOpTag LabelThreadOp = 498-primOpTag IsCurrentThreadBoundOp = 499-primOpTag NoDuplicateOp = 500-primOpTag ThreadStatusOp = 501-primOpTag MkWeakOp = 502-primOpTag MkWeakNoFinalizerOp = 503-primOpTag AddCFinalizerToWeakOp = 504-primOpTag DeRefWeakOp = 505-primOpTag FinalizeWeakOp = 506-primOpTag TouchOp = 507-primOpTag MakeStablePtrOp = 508-primOpTag DeRefStablePtrOp = 509-primOpTag EqStablePtrOp = 510-primOpTag MakeStableNameOp = 511-primOpTag EqStableNameOp = 512-primOpTag StableNameToIntOp = 513-primOpTag CompactNewOp = 514-primOpTag CompactResizeOp = 515-primOpTag CompactContainsOp = 516-primOpTag CompactContainsAnyOp = 517-primOpTag CompactGetFirstBlockOp = 518-primOpTag CompactGetNextBlockOp = 519-primOpTag CompactAllocateBlockOp = 520-primOpTag CompactFixupPointersOp = 521-primOpTag CompactAdd = 522-primOpTag CompactAddWithSharing = 523-primOpTag CompactSize = 524-primOpTag ReallyUnsafePtrEqualityOp = 525-primOpTag ParOp = 526-primOpTag SparkOp = 527-primOpTag SeqOp = 528-primOpTag GetSparkOp = 529-primOpTag NumSparks = 530-primOpTag DataToTagOp = 531-primOpTag TagToEnumOp = 532-primOpTag AddrToAnyOp = 533-primOpTag AnyToAddrOp = 534-primOpTag MkApUpd0_Op = 535-primOpTag NewBCOOp = 536-primOpTag UnpackClosureOp = 537-primOpTag ClosureSizeOp = 538-primOpTag GetApStackValOp = 539-primOpTag GetCCSOfOp = 540-primOpTag GetCurrentCCSOp = 541-primOpTag ClearCCSOp = 542-primOpTag TraceEventOp = 543-primOpTag TraceEventBinaryOp = 544-primOpTag TraceMarkerOp = 545-primOpTag SetThreadAllocationCounter = 546-primOpTag (VecBroadcastOp IntVec 16 W8) = 547-primOpTag (VecBroadcastOp IntVec 8 W16) = 548-primOpTag (VecBroadcastOp IntVec 4 W32) = 549-primOpTag (VecBroadcastOp IntVec 2 W64) = 550-primOpTag (VecBroadcastOp IntVec 32 W8) = 551-primOpTag (VecBroadcastOp IntVec 16 W16) = 552-primOpTag (VecBroadcastOp IntVec 8 W32) = 553-primOpTag (VecBroadcastOp IntVec 4 W64) = 554-primOpTag (VecBroadcastOp IntVec 64 W8) = 555-primOpTag (VecBroadcastOp IntVec 32 W16) = 556-primOpTag (VecBroadcastOp IntVec 16 W32) = 557-primOpTag (VecBroadcastOp IntVec 8 W64) = 558-primOpTag (VecBroadcastOp WordVec 16 W8) = 559-primOpTag (VecBroadcastOp WordVec 8 W16) = 560-primOpTag (VecBroadcastOp WordVec 4 W32) = 561-primOpTag (VecBroadcastOp WordVec 2 W64) = 562-primOpTag (VecBroadcastOp WordVec 32 W8) = 563-primOpTag (VecBroadcastOp WordVec 16 W16) = 564-primOpTag (VecBroadcastOp WordVec 8 W32) = 565-primOpTag (VecBroadcastOp WordVec 4 W64) = 566-primOpTag (VecBroadcastOp WordVec 64 W8) = 567-primOpTag (VecBroadcastOp WordVec 32 W16) = 568-primOpTag (VecBroadcastOp WordVec 16 W32) = 569-primOpTag (VecBroadcastOp WordVec 8 W64) = 570-primOpTag (VecBroadcastOp FloatVec 4 W32) = 571-primOpTag (VecBroadcastOp FloatVec 2 W64) = 572-primOpTag (VecBroadcastOp FloatVec 8 W32) = 573-primOpTag (VecBroadcastOp FloatVec 4 W64) = 574-primOpTag (VecBroadcastOp FloatVec 16 W32) = 575-primOpTag (VecBroadcastOp FloatVec 8 W64) = 576-primOpTag (VecPackOp IntVec 16 W8) = 577-primOpTag (VecPackOp IntVec 8 W16) = 578-primOpTag (VecPackOp IntVec 4 W32) = 579-primOpTag (VecPackOp IntVec 2 W64) = 580-primOpTag (VecPackOp IntVec 32 W8) = 581-primOpTag (VecPackOp IntVec 16 W16) = 582-primOpTag (VecPackOp IntVec 8 W32) = 583-primOpTag (VecPackOp IntVec 4 W64) = 584-primOpTag (VecPackOp IntVec 64 W8) = 585-primOpTag (VecPackOp IntVec 32 W16) = 586-primOpTag (VecPackOp IntVec 16 W32) = 587-primOpTag (VecPackOp IntVec 8 W64) = 588-primOpTag (VecPackOp WordVec 16 W8) = 589-primOpTag (VecPackOp WordVec 8 W16) = 590-primOpTag (VecPackOp WordVec 4 W32) = 591-primOpTag (VecPackOp WordVec 2 W64) = 592-primOpTag (VecPackOp WordVec 32 W8) = 593-primOpTag (VecPackOp WordVec 16 W16) = 594-primOpTag (VecPackOp WordVec 8 W32) = 595-primOpTag (VecPackOp WordVec 4 W64) = 596-primOpTag (VecPackOp WordVec 64 W8) = 597-primOpTag (VecPackOp WordVec 32 W16) = 598-primOpTag (VecPackOp WordVec 16 W32) = 599-primOpTag (VecPackOp WordVec 8 W64) = 600-primOpTag (VecPackOp FloatVec 4 W32) = 601-primOpTag (VecPackOp FloatVec 2 W64) = 602-primOpTag (VecPackOp FloatVec 8 W32) = 603-primOpTag (VecPackOp FloatVec 4 W64) = 604-primOpTag (VecPackOp FloatVec 16 W32) = 605-primOpTag (VecPackOp FloatVec 8 W64) = 606-primOpTag (VecUnpackOp IntVec 16 W8) = 607-primOpTag (VecUnpackOp IntVec 8 W16) = 608-primOpTag (VecUnpackOp IntVec 4 W32) = 609-primOpTag (VecUnpackOp IntVec 2 W64) = 610-primOpTag (VecUnpackOp IntVec 32 W8) = 611-primOpTag (VecUnpackOp IntVec 16 W16) = 612-primOpTag (VecUnpackOp IntVec 8 W32) = 613-primOpTag (VecUnpackOp IntVec 4 W64) = 614-primOpTag (VecUnpackOp IntVec 64 W8) = 615-primOpTag (VecUnpackOp IntVec 32 W16) = 616-primOpTag (VecUnpackOp IntVec 16 W32) = 617-primOpTag (VecUnpackOp IntVec 8 W64) = 618-primOpTag (VecUnpackOp WordVec 16 W8) = 619-primOpTag (VecUnpackOp WordVec 8 W16) = 620-primOpTag (VecUnpackOp WordVec 4 W32) = 621-primOpTag (VecUnpackOp WordVec 2 W64) = 622-primOpTag (VecUnpackOp WordVec 32 W8) = 623-primOpTag (VecUnpackOp WordVec 16 W16) = 624-primOpTag (VecUnpackOp WordVec 8 W32) = 625-primOpTag (VecUnpackOp WordVec 4 W64) = 626-primOpTag (VecUnpackOp WordVec 64 W8) = 627-primOpTag (VecUnpackOp WordVec 32 W16) = 628-primOpTag (VecUnpackOp WordVec 16 W32) = 629-primOpTag (VecUnpackOp WordVec 8 W64) = 630-primOpTag (VecUnpackOp FloatVec 4 W32) = 631-primOpTag (VecUnpackOp FloatVec 2 W64) = 632-primOpTag (VecUnpackOp FloatVec 8 W32) = 633-primOpTag (VecUnpackOp FloatVec 4 W64) = 634-primOpTag (VecUnpackOp FloatVec 16 W32) = 635-primOpTag (VecUnpackOp FloatVec 8 W64) = 636-primOpTag (VecInsertOp IntVec 16 W8) = 637-primOpTag (VecInsertOp IntVec 8 W16) = 638-primOpTag (VecInsertOp IntVec 4 W32) = 639-primOpTag (VecInsertOp IntVec 2 W64) = 640-primOpTag (VecInsertOp IntVec 32 W8) = 641-primOpTag (VecInsertOp IntVec 16 W16) = 642-primOpTag (VecInsertOp IntVec 8 W32) = 643-primOpTag (VecInsertOp IntVec 4 W64) = 644-primOpTag (VecInsertOp IntVec 64 W8) = 645-primOpTag (VecInsertOp IntVec 32 W16) = 646-primOpTag (VecInsertOp IntVec 16 W32) = 647-primOpTag (VecInsertOp IntVec 8 W64) = 648-primOpTag (VecInsertOp WordVec 16 W8) = 649-primOpTag (VecInsertOp WordVec 8 W16) = 650-primOpTag (VecInsertOp WordVec 4 W32) = 651-primOpTag (VecInsertOp WordVec 2 W64) = 652-primOpTag (VecInsertOp WordVec 32 W8) = 653-primOpTag (VecInsertOp WordVec 16 W16) = 654-primOpTag (VecInsertOp WordVec 8 W32) = 655-primOpTag (VecInsertOp WordVec 4 W64) = 656-primOpTag (VecInsertOp WordVec 64 W8) = 657-primOpTag (VecInsertOp WordVec 32 W16) = 658-primOpTag (VecInsertOp WordVec 16 W32) = 659-primOpTag (VecInsertOp WordVec 8 W64) = 660-primOpTag (VecInsertOp FloatVec 4 W32) = 661-primOpTag (VecInsertOp FloatVec 2 W64) = 662-primOpTag (VecInsertOp FloatVec 8 W32) = 663-primOpTag (VecInsertOp FloatVec 4 W64) = 664-primOpTag (VecInsertOp FloatVec 16 W32) = 665-primOpTag (VecInsertOp FloatVec 8 W64) = 666-primOpTag (VecAddOp IntVec 16 W8) = 667-primOpTag (VecAddOp IntVec 8 W16) = 668-primOpTag (VecAddOp IntVec 4 W32) = 669-primOpTag (VecAddOp IntVec 2 W64) = 670-primOpTag (VecAddOp IntVec 32 W8) = 671-primOpTag (VecAddOp IntVec 16 W16) = 672-primOpTag (VecAddOp IntVec 8 W32) = 673-primOpTag (VecAddOp IntVec 4 W64) = 674-primOpTag (VecAddOp IntVec 64 W8) = 675-primOpTag (VecAddOp IntVec 32 W16) = 676-primOpTag (VecAddOp IntVec 16 W32) = 677-primOpTag (VecAddOp IntVec 8 W64) = 678-primOpTag (VecAddOp WordVec 16 W8) = 679-primOpTag (VecAddOp WordVec 8 W16) = 680-primOpTag (VecAddOp WordVec 4 W32) = 681-primOpTag (VecAddOp WordVec 2 W64) = 682-primOpTag (VecAddOp WordVec 32 W8) = 683-primOpTag (VecAddOp WordVec 16 W16) = 684-primOpTag (VecAddOp WordVec 8 W32) = 685-primOpTag (VecAddOp WordVec 4 W64) = 686-primOpTag (VecAddOp WordVec 64 W8) = 687-primOpTag (VecAddOp WordVec 32 W16) = 688-primOpTag (VecAddOp WordVec 16 W32) = 689-primOpTag (VecAddOp WordVec 8 W64) = 690-primOpTag (VecAddOp FloatVec 4 W32) = 691-primOpTag (VecAddOp FloatVec 2 W64) = 692-primOpTag (VecAddOp FloatVec 8 W32) = 693-primOpTag (VecAddOp FloatVec 4 W64) = 694-primOpTag (VecAddOp FloatVec 16 W32) = 695-primOpTag (VecAddOp FloatVec 8 W64) = 696-primOpTag (VecSubOp IntVec 16 W8) = 697-primOpTag (VecSubOp IntVec 8 W16) = 698-primOpTag (VecSubOp IntVec 4 W32) = 699-primOpTag (VecSubOp IntVec 2 W64) = 700-primOpTag (VecSubOp IntVec 32 W8) = 701-primOpTag (VecSubOp IntVec 16 W16) = 702-primOpTag (VecSubOp IntVec 8 W32) = 703-primOpTag (VecSubOp IntVec 4 W64) = 704-primOpTag (VecSubOp IntVec 64 W8) = 705-primOpTag (VecSubOp IntVec 32 W16) = 706-primOpTag (VecSubOp IntVec 16 W32) = 707-primOpTag (VecSubOp IntVec 8 W64) = 708-primOpTag (VecSubOp WordVec 16 W8) = 709-primOpTag (VecSubOp WordVec 8 W16) = 710-primOpTag (VecSubOp WordVec 4 W32) = 711-primOpTag (VecSubOp WordVec 2 W64) = 712-primOpTag (VecSubOp WordVec 32 W8) = 713-primOpTag (VecSubOp WordVec 16 W16) = 714-primOpTag (VecSubOp WordVec 8 W32) = 715-primOpTag (VecSubOp WordVec 4 W64) = 716-primOpTag (VecSubOp WordVec 64 W8) = 717-primOpTag (VecSubOp WordVec 32 W16) = 718-primOpTag (VecSubOp WordVec 16 W32) = 719-primOpTag (VecSubOp WordVec 8 W64) = 720-primOpTag (VecSubOp FloatVec 4 W32) = 721-primOpTag (VecSubOp FloatVec 2 W64) = 722-primOpTag (VecSubOp FloatVec 8 W32) = 723-primOpTag (VecSubOp FloatVec 4 W64) = 724-primOpTag (VecSubOp FloatVec 16 W32) = 725-primOpTag (VecSubOp FloatVec 8 W64) = 726-primOpTag (VecMulOp IntVec 16 W8) = 727-primOpTag (VecMulOp IntVec 8 W16) = 728-primOpTag (VecMulOp IntVec 4 W32) = 729-primOpTag (VecMulOp IntVec 2 W64) = 730-primOpTag (VecMulOp IntVec 32 W8) = 731-primOpTag (VecMulOp IntVec 16 W16) = 732-primOpTag (VecMulOp IntVec 8 W32) = 733-primOpTag (VecMulOp IntVec 4 W64) = 734-primOpTag (VecMulOp IntVec 64 W8) = 735-primOpTag (VecMulOp IntVec 32 W16) = 736-primOpTag (VecMulOp IntVec 16 W32) = 737-primOpTag (VecMulOp IntVec 8 W64) = 738-primOpTag (VecMulOp WordVec 16 W8) = 739-primOpTag (VecMulOp WordVec 8 W16) = 740-primOpTag (VecMulOp WordVec 4 W32) = 741-primOpTag (VecMulOp WordVec 2 W64) = 742-primOpTag (VecMulOp WordVec 32 W8) = 743-primOpTag (VecMulOp WordVec 16 W16) = 744-primOpTag (VecMulOp WordVec 8 W32) = 745-primOpTag (VecMulOp WordVec 4 W64) = 746-primOpTag (VecMulOp WordVec 64 W8) = 747-primOpTag (VecMulOp WordVec 32 W16) = 748-primOpTag (VecMulOp WordVec 16 W32) = 749-primOpTag (VecMulOp WordVec 8 W64) = 750-primOpTag (VecMulOp FloatVec 4 W32) = 751-primOpTag (VecMulOp FloatVec 2 W64) = 752-primOpTag (VecMulOp FloatVec 8 W32) = 753-primOpTag (VecMulOp FloatVec 4 W64) = 754-primOpTag (VecMulOp FloatVec 16 W32) = 755-primOpTag (VecMulOp FloatVec 8 W64) = 756-primOpTag (VecDivOp FloatVec 4 W32) = 757-primOpTag (VecDivOp FloatVec 2 W64) = 758-primOpTag (VecDivOp FloatVec 8 W32) = 759-primOpTag (VecDivOp FloatVec 4 W64) = 760-primOpTag (VecDivOp FloatVec 16 W32) = 761-primOpTag (VecDivOp FloatVec 8 W64) = 762-primOpTag (VecQuotOp IntVec 16 W8) = 763-primOpTag (VecQuotOp IntVec 8 W16) = 764-primOpTag (VecQuotOp IntVec 4 W32) = 765-primOpTag (VecQuotOp IntVec 2 W64) = 766-primOpTag (VecQuotOp IntVec 32 W8) = 767-primOpTag (VecQuotOp IntVec 16 W16) = 768-primOpTag (VecQuotOp IntVec 8 W32) = 769-primOpTag (VecQuotOp IntVec 4 W64) = 770-primOpTag (VecQuotOp IntVec 64 W8) = 771-primOpTag (VecQuotOp IntVec 32 W16) = 772-primOpTag (VecQuotOp IntVec 16 W32) = 773-primOpTag (VecQuotOp IntVec 8 W64) = 774-primOpTag (VecQuotOp WordVec 16 W8) = 775-primOpTag (VecQuotOp WordVec 8 W16) = 776-primOpTag (VecQuotOp WordVec 4 W32) = 777-primOpTag (VecQuotOp WordVec 2 W64) = 778-primOpTag (VecQuotOp WordVec 32 W8) = 779-primOpTag (VecQuotOp WordVec 16 W16) = 780-primOpTag (VecQuotOp WordVec 8 W32) = 781-primOpTag (VecQuotOp WordVec 4 W64) = 782-primOpTag (VecQuotOp WordVec 64 W8) = 783-primOpTag (VecQuotOp WordVec 32 W16) = 784-primOpTag (VecQuotOp WordVec 16 W32) = 785-primOpTag (VecQuotOp WordVec 8 W64) = 786-primOpTag (VecRemOp IntVec 16 W8) = 787-primOpTag (VecRemOp IntVec 8 W16) = 788-primOpTag (VecRemOp IntVec 4 W32) = 789-primOpTag (VecRemOp IntVec 2 W64) = 790-primOpTag (VecRemOp IntVec 32 W8) = 791-primOpTag (VecRemOp IntVec 16 W16) = 792-primOpTag (VecRemOp IntVec 8 W32) = 793-primOpTag (VecRemOp IntVec 4 W64) = 794-primOpTag (VecRemOp IntVec 64 W8) = 795-primOpTag (VecRemOp IntVec 32 W16) = 796-primOpTag (VecRemOp IntVec 16 W32) = 797-primOpTag (VecRemOp IntVec 8 W64) = 798-primOpTag (VecRemOp WordVec 16 W8) = 799-primOpTag (VecRemOp WordVec 8 W16) = 800-primOpTag (VecRemOp WordVec 4 W32) = 801-primOpTag (VecRemOp WordVec 2 W64) = 802-primOpTag (VecRemOp WordVec 32 W8) = 803-primOpTag (VecRemOp WordVec 16 W16) = 804-primOpTag (VecRemOp WordVec 8 W32) = 805-primOpTag (VecRemOp WordVec 4 W64) = 806-primOpTag (VecRemOp WordVec 64 W8) = 807-primOpTag (VecRemOp WordVec 32 W16) = 808-primOpTag (VecRemOp WordVec 16 W32) = 809-primOpTag (VecRemOp WordVec 8 W64) = 810-primOpTag (VecNegOp IntVec 16 W8) = 811-primOpTag (VecNegOp IntVec 8 W16) = 812-primOpTag (VecNegOp IntVec 4 W32) = 813-primOpTag (VecNegOp IntVec 2 W64) = 814-primOpTag (VecNegOp IntVec 32 W8) = 815-primOpTag (VecNegOp IntVec 16 W16) = 816-primOpTag (VecNegOp IntVec 8 W32) = 817-primOpTag (VecNegOp IntVec 4 W64) = 818-primOpTag (VecNegOp IntVec 64 W8) = 819-primOpTag (VecNegOp IntVec 32 W16) = 820-primOpTag (VecNegOp IntVec 16 W32) = 821-primOpTag (VecNegOp IntVec 8 W64) = 822-primOpTag (VecNegOp FloatVec 4 W32) = 823-primOpTag (VecNegOp FloatVec 2 W64) = 824-primOpTag (VecNegOp FloatVec 8 W32) = 825-primOpTag (VecNegOp FloatVec 4 W64) = 826-primOpTag (VecNegOp FloatVec 16 W32) = 827-primOpTag (VecNegOp FloatVec 8 W64) = 828-primOpTag (VecIndexByteArrayOp IntVec 16 W8) = 829-primOpTag (VecIndexByteArrayOp IntVec 8 W16) = 830-primOpTag (VecIndexByteArrayOp IntVec 4 W32) = 831-primOpTag (VecIndexByteArrayOp IntVec 2 W64) = 832-primOpTag (VecIndexByteArrayOp IntVec 32 W8) = 833-primOpTag (VecIndexByteArrayOp IntVec 16 W16) = 834-primOpTag (VecIndexByteArrayOp IntVec 8 W32) = 835-primOpTag (VecIndexByteArrayOp IntVec 4 W64) = 836-primOpTag (VecIndexByteArrayOp IntVec 64 W8) = 837-primOpTag (VecIndexByteArrayOp IntVec 32 W16) = 838-primOpTag (VecIndexByteArrayOp IntVec 16 W32) = 839-primOpTag (VecIndexByteArrayOp IntVec 8 W64) = 840-primOpTag (VecIndexByteArrayOp WordVec 16 W8) = 841-primOpTag (VecIndexByteArrayOp WordVec 8 W16) = 842-primOpTag (VecIndexByteArrayOp WordVec 4 W32) = 843-primOpTag (VecIndexByteArrayOp WordVec 2 W64) = 844-primOpTag (VecIndexByteArrayOp WordVec 32 W8) = 845-primOpTag (VecIndexByteArrayOp WordVec 16 W16) = 846-primOpTag (VecIndexByteArrayOp WordVec 8 W32) = 847-primOpTag (VecIndexByteArrayOp WordVec 4 W64) = 848-primOpTag (VecIndexByteArrayOp WordVec 64 W8) = 849-primOpTag (VecIndexByteArrayOp WordVec 32 W16) = 850-primOpTag (VecIndexByteArrayOp WordVec 16 W32) = 851-primOpTag (VecIndexByteArrayOp WordVec 8 W64) = 852-primOpTag (VecIndexByteArrayOp FloatVec 4 W32) = 853-primOpTag (VecIndexByteArrayOp FloatVec 2 W64) = 854-primOpTag (VecIndexByteArrayOp FloatVec 8 W32) = 855-primOpTag (VecIndexByteArrayOp FloatVec 4 W64) = 856-primOpTag (VecIndexByteArrayOp FloatVec 16 W32) = 857-primOpTag (VecIndexByteArrayOp FloatVec 8 W64) = 858-primOpTag (VecReadByteArrayOp IntVec 16 W8) = 859-primOpTag (VecReadByteArrayOp IntVec 8 W16) = 860-primOpTag (VecReadByteArrayOp IntVec 4 W32) = 861-primOpTag (VecReadByteArrayOp IntVec 2 W64) = 862-primOpTag (VecReadByteArrayOp IntVec 32 W8) = 863-primOpTag (VecReadByteArrayOp IntVec 16 W16) = 864-primOpTag (VecReadByteArrayOp IntVec 8 W32) = 865-primOpTag (VecReadByteArrayOp IntVec 4 W64) = 866-primOpTag (VecReadByteArrayOp IntVec 64 W8) = 867-primOpTag (VecReadByteArrayOp IntVec 32 W16) = 868-primOpTag (VecReadByteArrayOp IntVec 16 W32) = 869-primOpTag (VecReadByteArrayOp IntVec 8 W64) = 870-primOpTag (VecReadByteArrayOp WordVec 16 W8) = 871-primOpTag (VecReadByteArrayOp WordVec 8 W16) = 872-primOpTag (VecReadByteArrayOp WordVec 4 W32) = 873-primOpTag (VecReadByteArrayOp WordVec 2 W64) = 874-primOpTag (VecReadByteArrayOp WordVec 32 W8) = 875-primOpTag (VecReadByteArrayOp WordVec 16 W16) = 876-primOpTag (VecReadByteArrayOp WordVec 8 W32) = 877-primOpTag (VecReadByteArrayOp WordVec 4 W64) = 878-primOpTag (VecReadByteArrayOp WordVec 64 W8) = 879-primOpTag (VecReadByteArrayOp WordVec 32 W16) = 880-primOpTag (VecReadByteArrayOp WordVec 16 W32) = 881-primOpTag (VecReadByteArrayOp WordVec 8 W64) = 882-primOpTag (VecReadByteArrayOp FloatVec 4 W32) = 883-primOpTag (VecReadByteArrayOp FloatVec 2 W64) = 884-primOpTag (VecReadByteArrayOp FloatVec 8 W32) = 885-primOpTag (VecReadByteArrayOp FloatVec 4 W64) = 886-primOpTag (VecReadByteArrayOp FloatVec 16 W32) = 887-primOpTag (VecReadByteArrayOp FloatVec 8 W64) = 888-primOpTag (VecWriteByteArrayOp IntVec 16 W8) = 889-primOpTag (VecWriteByteArrayOp IntVec 8 W16) = 890-primOpTag (VecWriteByteArrayOp IntVec 4 W32) = 891-primOpTag (VecWriteByteArrayOp IntVec 2 W64) = 892-primOpTag (VecWriteByteArrayOp IntVec 32 W8) = 893-primOpTag (VecWriteByteArrayOp IntVec 16 W16) = 894-primOpTag (VecWriteByteArrayOp IntVec 8 W32) = 895-primOpTag (VecWriteByteArrayOp IntVec 4 W64) = 896-primOpTag (VecWriteByteArrayOp IntVec 64 W8) = 897-primOpTag (VecWriteByteArrayOp IntVec 32 W16) = 898-primOpTag (VecWriteByteArrayOp IntVec 16 W32) = 899-primOpTag (VecWriteByteArrayOp IntVec 8 W64) = 900-primOpTag (VecWriteByteArrayOp WordVec 16 W8) = 901-primOpTag (VecWriteByteArrayOp WordVec 8 W16) = 902-primOpTag (VecWriteByteArrayOp WordVec 4 W32) = 903-primOpTag (VecWriteByteArrayOp WordVec 2 W64) = 904-primOpTag (VecWriteByteArrayOp WordVec 32 W8) = 905-primOpTag (VecWriteByteArrayOp WordVec 16 W16) = 906-primOpTag (VecWriteByteArrayOp WordVec 8 W32) = 907-primOpTag (VecWriteByteArrayOp WordVec 4 W64) = 908-primOpTag (VecWriteByteArrayOp WordVec 64 W8) = 909-primOpTag (VecWriteByteArrayOp WordVec 32 W16) = 910-primOpTag (VecWriteByteArrayOp WordVec 16 W32) = 911-primOpTag (VecWriteByteArrayOp WordVec 8 W64) = 912-primOpTag (VecWriteByteArrayOp FloatVec 4 W32) = 913-primOpTag (VecWriteByteArrayOp FloatVec 2 W64) = 914-primOpTag (VecWriteByteArrayOp FloatVec 8 W32) = 915-primOpTag (VecWriteByteArrayOp FloatVec 4 W64) = 916-primOpTag (VecWriteByteArrayOp FloatVec 16 W32) = 917-primOpTag (VecWriteByteArrayOp FloatVec 8 W64) = 918-primOpTag (VecIndexOffAddrOp IntVec 16 W8) = 919-primOpTag (VecIndexOffAddrOp IntVec 8 W16) = 920-primOpTag (VecIndexOffAddrOp IntVec 4 W32) = 921-primOpTag (VecIndexOffAddrOp IntVec 2 W64) = 922-primOpTag (VecIndexOffAddrOp IntVec 32 W8) = 923-primOpTag (VecIndexOffAddrOp IntVec 16 W16) = 924-primOpTag (VecIndexOffAddrOp IntVec 8 W32) = 925-primOpTag (VecIndexOffAddrOp IntVec 4 W64) = 926-primOpTag (VecIndexOffAddrOp IntVec 64 W8) = 927-primOpTag (VecIndexOffAddrOp IntVec 32 W16) = 928-primOpTag (VecIndexOffAddrOp IntVec 16 W32) = 929-primOpTag (VecIndexOffAddrOp IntVec 8 W64) = 930-primOpTag (VecIndexOffAddrOp WordVec 16 W8) = 931-primOpTag (VecIndexOffAddrOp WordVec 8 W16) = 932-primOpTag (VecIndexOffAddrOp WordVec 4 W32) = 933-primOpTag (VecIndexOffAddrOp WordVec 2 W64) = 934-primOpTag (VecIndexOffAddrOp WordVec 32 W8) = 935-primOpTag (VecIndexOffAddrOp WordVec 16 W16) = 936-primOpTag (VecIndexOffAddrOp WordVec 8 W32) = 937-primOpTag (VecIndexOffAddrOp WordVec 4 W64) = 938-primOpTag (VecIndexOffAddrOp WordVec 64 W8) = 939-primOpTag (VecIndexOffAddrOp WordVec 32 W16) = 940-primOpTag (VecIndexOffAddrOp WordVec 16 W32) = 941-primOpTag (VecIndexOffAddrOp WordVec 8 W64) = 942-primOpTag (VecIndexOffAddrOp FloatVec 4 W32) = 943-primOpTag (VecIndexOffAddrOp FloatVec 2 W64) = 944-primOpTag (VecIndexOffAddrOp FloatVec 8 W32) = 945-primOpTag (VecIndexOffAddrOp FloatVec 4 W64) = 946-primOpTag (VecIndexOffAddrOp FloatVec 16 W32) = 947-primOpTag (VecIndexOffAddrOp FloatVec 8 W64) = 948-primOpTag (VecReadOffAddrOp IntVec 16 W8) = 949-primOpTag (VecReadOffAddrOp IntVec 8 W16) = 950-primOpTag (VecReadOffAddrOp IntVec 4 W32) = 951-primOpTag (VecReadOffAddrOp IntVec 2 W64) = 952-primOpTag (VecReadOffAddrOp IntVec 32 W8) = 953-primOpTag (VecReadOffAddrOp IntVec 16 W16) = 954-primOpTag (VecReadOffAddrOp IntVec 8 W32) = 955-primOpTag (VecReadOffAddrOp IntVec 4 W64) = 956-primOpTag (VecReadOffAddrOp IntVec 64 W8) = 957-primOpTag (VecReadOffAddrOp IntVec 32 W16) = 958-primOpTag (VecReadOffAddrOp IntVec 16 W32) = 959-primOpTag (VecReadOffAddrOp IntVec 8 W64) = 960-primOpTag (VecReadOffAddrOp WordVec 16 W8) = 961-primOpTag (VecReadOffAddrOp WordVec 8 W16) = 962-primOpTag (VecReadOffAddrOp WordVec 4 W32) = 963-primOpTag (VecReadOffAddrOp WordVec 2 W64) = 964-primOpTag (VecReadOffAddrOp WordVec 32 W8) = 965-primOpTag (VecReadOffAddrOp WordVec 16 W16) = 966-primOpTag (VecReadOffAddrOp WordVec 8 W32) = 967-primOpTag (VecReadOffAddrOp WordVec 4 W64) = 968-primOpTag (VecReadOffAddrOp WordVec 64 W8) = 969-primOpTag (VecReadOffAddrOp WordVec 32 W16) = 970-primOpTag (VecReadOffAddrOp WordVec 16 W32) = 971-primOpTag (VecReadOffAddrOp WordVec 8 W64) = 972-primOpTag (VecReadOffAddrOp FloatVec 4 W32) = 973-primOpTag (VecReadOffAddrOp FloatVec 2 W64) = 974-primOpTag (VecReadOffAddrOp FloatVec 8 W32) = 975-primOpTag (VecReadOffAddrOp FloatVec 4 W64) = 976-primOpTag (VecReadOffAddrOp FloatVec 16 W32) = 977-primOpTag (VecReadOffAddrOp FloatVec 8 W64) = 978-primOpTag (VecWriteOffAddrOp IntVec 16 W8) = 979-primOpTag (VecWriteOffAddrOp IntVec 8 W16) = 980-primOpTag (VecWriteOffAddrOp IntVec 4 W32) = 981-primOpTag (VecWriteOffAddrOp IntVec 2 W64) = 982-primOpTag (VecWriteOffAddrOp IntVec 32 W8) = 983-primOpTag (VecWriteOffAddrOp IntVec 16 W16) = 984-primOpTag (VecWriteOffAddrOp IntVec 8 W32) = 985-primOpTag (VecWriteOffAddrOp IntVec 4 W64) = 986-primOpTag (VecWriteOffAddrOp IntVec 64 W8) = 987-primOpTag (VecWriteOffAddrOp IntVec 32 W16) = 988-primOpTag (VecWriteOffAddrOp IntVec 16 W32) = 989-primOpTag (VecWriteOffAddrOp IntVec 8 W64) = 990-primOpTag (VecWriteOffAddrOp WordVec 16 W8) = 991-primOpTag (VecWriteOffAddrOp WordVec 8 W16) = 992-primOpTag (VecWriteOffAddrOp WordVec 4 W32) = 993-primOpTag (VecWriteOffAddrOp WordVec 2 W64) = 994-primOpTag (VecWriteOffAddrOp WordVec 32 W8) = 995-primOpTag (VecWriteOffAddrOp WordVec 16 W16) = 996-primOpTag (VecWriteOffAddrOp WordVec 8 W32) = 997-primOpTag (VecWriteOffAddrOp WordVec 4 W64) = 998-primOpTag (VecWriteOffAddrOp WordVec 64 W8) = 999-primOpTag (VecWriteOffAddrOp WordVec 32 W16) = 1000-primOpTag (VecWriteOffAddrOp WordVec 16 W32) = 1001-primOpTag (VecWriteOffAddrOp WordVec 8 W64) = 1002-primOpTag (VecWriteOffAddrOp FloatVec 4 W32) = 1003-primOpTag (VecWriteOffAddrOp FloatVec 2 W64) = 1004-primOpTag (VecWriteOffAddrOp FloatVec 8 W32) = 1005-primOpTag (VecWriteOffAddrOp FloatVec 4 W64) = 1006-primOpTag (VecWriteOffAddrOp FloatVec 16 W32) = 1007-primOpTag (VecWriteOffAddrOp FloatVec 8 W64) = 1008-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W8) = 1009-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W16) = 1010-primOpTag (VecIndexScalarByteArrayOp IntVec 4 W32) = 1011-primOpTag (VecIndexScalarByteArrayOp IntVec 2 W64) = 1012-primOpTag (VecIndexScalarByteArrayOp IntVec 32 W8) = 1013-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W16) = 1014-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W32) = 1015-primOpTag (VecIndexScalarByteArrayOp IntVec 4 W64) = 1016-primOpTag (VecIndexScalarByteArrayOp IntVec 64 W8) = 1017-primOpTag (VecIndexScalarByteArrayOp IntVec 32 W16) = 1018-primOpTag (VecIndexScalarByteArrayOp IntVec 16 W32) = 1019-primOpTag (VecIndexScalarByteArrayOp IntVec 8 W64) = 1020-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W8) = 1021-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W16) = 1022-primOpTag (VecIndexScalarByteArrayOp WordVec 4 W32) = 1023-primOpTag (VecIndexScalarByteArrayOp WordVec 2 W64) = 1024-primOpTag (VecIndexScalarByteArrayOp WordVec 32 W8) = 1025-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W16) = 1026-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W32) = 1027-primOpTag (VecIndexScalarByteArrayOp WordVec 4 W64) = 1028-primOpTag (VecIndexScalarByteArrayOp WordVec 64 W8) = 1029-primOpTag (VecIndexScalarByteArrayOp WordVec 32 W16) = 1030-primOpTag (VecIndexScalarByteArrayOp WordVec 16 W32) = 1031-primOpTag (VecIndexScalarByteArrayOp WordVec 8 W64) = 1032-primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W32) = 1033-primOpTag (VecIndexScalarByteArrayOp FloatVec 2 W64) = 1034-primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W32) = 1035-primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W64) = 1036-primOpTag (VecIndexScalarByteArrayOp FloatVec 16 W32) = 1037-primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W64) = 1038-primOpTag (VecReadScalarByteArrayOp IntVec 16 W8) = 1039-primOpTag (VecReadScalarByteArrayOp IntVec 8 W16) = 1040-primOpTag (VecReadScalarByteArrayOp IntVec 4 W32) = 1041-primOpTag (VecReadScalarByteArrayOp IntVec 2 W64) = 1042-primOpTag (VecReadScalarByteArrayOp IntVec 32 W8) = 1043-primOpTag (VecReadScalarByteArrayOp IntVec 16 W16) = 1044-primOpTag (VecReadScalarByteArrayOp IntVec 8 W32) = 1045-primOpTag (VecReadScalarByteArrayOp IntVec 4 W64) = 1046-primOpTag (VecReadScalarByteArrayOp IntVec 64 W8) = 1047-primOpTag (VecReadScalarByteArrayOp IntVec 32 W16) = 1048-primOpTag (VecReadScalarByteArrayOp IntVec 16 W32) = 1049-primOpTag (VecReadScalarByteArrayOp IntVec 8 W64) = 1050-primOpTag (VecReadScalarByteArrayOp WordVec 16 W8) = 1051-primOpTag (VecReadScalarByteArrayOp WordVec 8 W16) = 1052-primOpTag (VecReadScalarByteArrayOp WordVec 4 W32) = 1053-primOpTag (VecReadScalarByteArrayOp WordVec 2 W64) = 1054-primOpTag (VecReadScalarByteArrayOp WordVec 32 W8) = 1055-primOpTag (VecReadScalarByteArrayOp WordVec 16 W16) = 1056-primOpTag (VecReadScalarByteArrayOp WordVec 8 W32) = 1057-primOpTag (VecReadScalarByteArrayOp WordVec 4 W64) = 1058-primOpTag (VecReadScalarByteArrayOp WordVec 64 W8) = 1059-primOpTag (VecReadScalarByteArrayOp WordVec 32 W16) = 1060-primOpTag (VecReadScalarByteArrayOp WordVec 16 W32) = 1061-primOpTag (VecReadScalarByteArrayOp WordVec 8 W64) = 1062-primOpTag (VecReadScalarByteArrayOp FloatVec 4 W32) = 1063-primOpTag (VecReadScalarByteArrayOp FloatVec 2 W64) = 1064-primOpTag (VecReadScalarByteArrayOp FloatVec 8 W32) = 1065-primOpTag (VecReadScalarByteArrayOp FloatVec 4 W64) = 1066-primOpTag (VecReadScalarByteArrayOp FloatVec 16 W32) = 1067-primOpTag (VecReadScalarByteArrayOp FloatVec 8 W64) = 1068-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W8) = 1069-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W16) = 1070-primOpTag (VecWriteScalarByteArrayOp IntVec 4 W32) = 1071-primOpTag (VecWriteScalarByteArrayOp IntVec 2 W64) = 1072-primOpTag (VecWriteScalarByteArrayOp IntVec 32 W8) = 1073-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W16) = 1074-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W32) = 1075-primOpTag (VecWriteScalarByteArrayOp IntVec 4 W64) = 1076-primOpTag (VecWriteScalarByteArrayOp IntVec 64 W8) = 1077-primOpTag (VecWriteScalarByteArrayOp IntVec 32 W16) = 1078-primOpTag (VecWriteScalarByteArrayOp IntVec 16 W32) = 1079-primOpTag (VecWriteScalarByteArrayOp IntVec 8 W64) = 1080-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W8) = 1081-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W16) = 1082-primOpTag (VecWriteScalarByteArrayOp WordVec 4 W32) = 1083-primOpTag (VecWriteScalarByteArrayOp WordVec 2 W64) = 1084-primOpTag (VecWriteScalarByteArrayOp WordVec 32 W8) = 1085-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W16) = 1086-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W32) = 1087-primOpTag (VecWriteScalarByteArrayOp WordVec 4 W64) = 1088-primOpTag (VecWriteScalarByteArrayOp WordVec 64 W8) = 1089-primOpTag (VecWriteScalarByteArrayOp WordVec 32 W16) = 1090-primOpTag (VecWriteScalarByteArrayOp WordVec 16 W32) = 1091-primOpTag (VecWriteScalarByteArrayOp WordVec 8 W64) = 1092-primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W32) = 1093-primOpTag (VecWriteScalarByteArrayOp FloatVec 2 W64) = 1094-primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W32) = 1095-primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W64) = 1096-primOpTag (VecWriteScalarByteArrayOp FloatVec 16 W32) = 1097-primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W64) = 1098-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W8) = 1099-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W16) = 1100-primOpTag (VecIndexScalarOffAddrOp IntVec 4 W32) = 1101-primOpTag (VecIndexScalarOffAddrOp IntVec 2 W64) = 1102-primOpTag (VecIndexScalarOffAddrOp IntVec 32 W8) = 1103-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W16) = 1104-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W32) = 1105-primOpTag (VecIndexScalarOffAddrOp IntVec 4 W64) = 1106-primOpTag (VecIndexScalarOffAddrOp IntVec 64 W8) = 1107-primOpTag (VecIndexScalarOffAddrOp IntVec 32 W16) = 1108-primOpTag (VecIndexScalarOffAddrOp IntVec 16 W32) = 1109-primOpTag (VecIndexScalarOffAddrOp IntVec 8 W64) = 1110-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W8) = 1111-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W16) = 1112-primOpTag (VecIndexScalarOffAddrOp WordVec 4 W32) = 1113-primOpTag (VecIndexScalarOffAddrOp WordVec 2 W64) = 1114-primOpTag (VecIndexScalarOffAddrOp WordVec 32 W8) = 1115-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W16) = 1116-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W32) = 1117-primOpTag (VecIndexScalarOffAddrOp WordVec 4 W64) = 1118-primOpTag (VecIndexScalarOffAddrOp WordVec 64 W8) = 1119-primOpTag (VecIndexScalarOffAddrOp WordVec 32 W16) = 1120-primOpTag (VecIndexScalarOffAddrOp WordVec 16 W32) = 1121-primOpTag (VecIndexScalarOffAddrOp WordVec 8 W64) = 1122-primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W32) = 1123-primOpTag (VecIndexScalarOffAddrOp FloatVec 2 W64) = 1124-primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W32) = 1125-primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W64) = 1126-primOpTag (VecIndexScalarOffAddrOp FloatVec 16 W32) = 1127-primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W64) = 1128-primOpTag (VecReadScalarOffAddrOp IntVec 16 W8) = 1129-primOpTag (VecReadScalarOffAddrOp IntVec 8 W16) = 1130-primOpTag (VecReadScalarOffAddrOp IntVec 4 W32) = 1131-primOpTag (VecReadScalarOffAddrOp IntVec 2 W64) = 1132-primOpTag (VecReadScalarOffAddrOp IntVec 32 W8) = 1133-primOpTag (VecReadScalarOffAddrOp IntVec 16 W16) = 1134-primOpTag (VecReadScalarOffAddrOp IntVec 8 W32) = 1135-primOpTag (VecReadScalarOffAddrOp IntVec 4 W64) = 1136-primOpTag (VecReadScalarOffAddrOp IntVec 64 W8) = 1137-primOpTag (VecReadScalarOffAddrOp IntVec 32 W16) = 1138-primOpTag (VecReadScalarOffAddrOp IntVec 16 W32) = 1139-primOpTag (VecReadScalarOffAddrOp IntVec 8 W64) = 1140-primOpTag (VecReadScalarOffAddrOp WordVec 16 W8) = 1141-primOpTag (VecReadScalarOffAddrOp WordVec 8 W16) = 1142-primOpTag (VecReadScalarOffAddrOp WordVec 4 W32) = 1143-primOpTag (VecReadScalarOffAddrOp WordVec 2 W64) = 1144-primOpTag (VecReadScalarOffAddrOp WordVec 32 W8) = 1145-primOpTag (VecReadScalarOffAddrOp WordVec 16 W16) = 1146-primOpTag (VecReadScalarOffAddrOp WordVec 8 W32) = 1147-primOpTag (VecReadScalarOffAddrOp WordVec 4 W64) = 1148-primOpTag (VecReadScalarOffAddrOp WordVec 64 W8) = 1149-primOpTag (VecReadScalarOffAddrOp WordVec 32 W16) = 1150-primOpTag (VecReadScalarOffAddrOp WordVec 16 W32) = 1151-primOpTag (VecReadScalarOffAddrOp WordVec 8 W64) = 1152-primOpTag (VecReadScalarOffAddrOp FloatVec 4 W32) = 1153-primOpTag (VecReadScalarOffAddrOp FloatVec 2 W64) = 1154-primOpTag (VecReadScalarOffAddrOp FloatVec 8 W32) = 1155-primOpTag (VecReadScalarOffAddrOp FloatVec 4 W64) = 1156-primOpTag (VecReadScalarOffAddrOp FloatVec 16 W32) = 1157-primOpTag (VecReadScalarOffAddrOp FloatVec 8 W64) = 1158-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W8) = 1159-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W16) = 1160-primOpTag (VecWriteScalarOffAddrOp IntVec 4 W32) = 1161-primOpTag (VecWriteScalarOffAddrOp IntVec 2 W64) = 1162-primOpTag (VecWriteScalarOffAddrOp IntVec 32 W8) = 1163-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W16) = 1164-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W32) = 1165-primOpTag (VecWriteScalarOffAddrOp IntVec 4 W64) = 1166-primOpTag (VecWriteScalarOffAddrOp IntVec 64 W8) = 1167-primOpTag (VecWriteScalarOffAddrOp IntVec 32 W16) = 1168-primOpTag (VecWriteScalarOffAddrOp IntVec 16 W32) = 1169-primOpTag (VecWriteScalarOffAddrOp IntVec 8 W64) = 1170-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W8) = 1171-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W16) = 1172-primOpTag (VecWriteScalarOffAddrOp WordVec 4 W32) = 1173-primOpTag (VecWriteScalarOffAddrOp WordVec 2 W64) = 1174-primOpTag (VecWriteScalarOffAddrOp WordVec 32 W8) = 1175-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W16) = 1176-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W32) = 1177-primOpTag (VecWriteScalarOffAddrOp WordVec 4 W64) = 1178-primOpTag (VecWriteScalarOffAddrOp WordVec 64 W8) = 1179-primOpTag (VecWriteScalarOffAddrOp WordVec 32 W16) = 1180-primOpTag (VecWriteScalarOffAddrOp WordVec 16 W32) = 1181-primOpTag (VecWriteScalarOffAddrOp WordVec 8 W64) = 1182-primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W32) = 1183-primOpTag (VecWriteScalarOffAddrOp FloatVec 2 W64) = 1184-primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W32) = 1185-primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W64) = 1186-primOpTag (VecWriteScalarOffAddrOp FloatVec 16 W32) = 1187-primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W64) = 1188-primOpTag PrefetchByteArrayOp3 = 1189-primOpTag PrefetchMutableByteArrayOp3 = 1190-primOpTag PrefetchAddrOp3 = 1191-primOpTag PrefetchValueOp3 = 1192-primOpTag PrefetchByteArrayOp2 = 1193-primOpTag PrefetchMutableByteArrayOp2 = 1194-primOpTag PrefetchAddrOp2 = 1195-primOpTag PrefetchValueOp2 = 1196-primOpTag PrefetchByteArrayOp1 = 1197-primOpTag PrefetchMutableByteArrayOp1 = 1198-primOpTag PrefetchAddrOp1 = 1199-primOpTag PrefetchValueOp1 = 1200-primOpTag PrefetchByteArrayOp0 = 1201-primOpTag PrefetchMutableByteArrayOp0 = 1202-primOpTag PrefetchAddrOp0 = 1203-primOpTag PrefetchValueOp0 = 1204+maxPrimOpTag = 1207+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 Int8Extend = 8+primOpTag Int8Narrow = 9+primOpTag Int8NegOp = 10+primOpTag Int8AddOp = 11+primOpTag Int8SubOp = 12+primOpTag Int8MulOp = 13+primOpTag Int8QuotOp = 14+primOpTag Int8RemOp = 15+primOpTag Int8QuotRemOp = 16+primOpTag Int8EqOp = 17+primOpTag Int8GeOp = 18+primOpTag Int8GtOp = 19+primOpTag Int8LeOp = 20+primOpTag Int8LtOp = 21+primOpTag Int8NeOp = 22+primOpTag Word8Extend = 23+primOpTag Word8Narrow = 24+primOpTag Word8NotOp = 25+primOpTag Word8AddOp = 26+primOpTag Word8SubOp = 27+primOpTag Word8MulOp = 28+primOpTag Word8QuotOp = 29+primOpTag Word8RemOp = 30+primOpTag Word8QuotRemOp = 31+primOpTag Word8EqOp = 32+primOpTag Word8GeOp = 33+primOpTag Word8GtOp = 34+primOpTag Word8LeOp = 35+primOpTag Word8LtOp = 36+primOpTag Word8NeOp = 37+primOpTag Int16Extend = 38+primOpTag Int16Narrow = 39+primOpTag Int16NegOp = 40+primOpTag Int16AddOp = 41+primOpTag Int16SubOp = 42+primOpTag Int16MulOp = 43+primOpTag Int16QuotOp = 44+primOpTag Int16RemOp = 45+primOpTag Int16QuotRemOp = 46+primOpTag Int16EqOp = 47+primOpTag Int16GeOp = 48+primOpTag Int16GtOp = 49+primOpTag Int16LeOp = 50+primOpTag Int16LtOp = 51+primOpTag Int16NeOp = 52+primOpTag Word16Extend = 53+primOpTag Word16Narrow = 54+primOpTag Word16NotOp = 55+primOpTag Word16AddOp = 56+primOpTag Word16SubOp = 57+primOpTag Word16MulOp = 58+primOpTag Word16QuotOp = 59+primOpTag Word16RemOp = 60+primOpTag Word16QuotRemOp = 61+primOpTag Word16EqOp = 62+primOpTag Word16GeOp = 63+primOpTag Word16GtOp = 64+primOpTag Word16LeOp = 65+primOpTag Word16LtOp = 66+primOpTag Word16NeOp = 67+primOpTag IntAddOp = 68+primOpTag IntSubOp = 69+primOpTag IntMulOp = 70+primOpTag IntMul2Op = 71+primOpTag IntMulMayOfloOp = 72+primOpTag IntQuotOp = 73+primOpTag IntRemOp = 74+primOpTag IntQuotRemOp = 75+primOpTag AndIOp = 76+primOpTag OrIOp = 77+primOpTag XorIOp = 78+primOpTag NotIOp = 79+primOpTag IntNegOp = 80+primOpTag IntAddCOp = 81+primOpTag IntSubCOp = 82+primOpTag IntGtOp = 83+primOpTag IntGeOp = 84+primOpTag IntEqOp = 85+primOpTag IntNeOp = 86+primOpTag IntLtOp = 87+primOpTag IntLeOp = 88+primOpTag ChrOp = 89+primOpTag Int2WordOp = 90+primOpTag Int2FloatOp = 91+primOpTag Int2DoubleOp = 92+primOpTag Word2FloatOp = 93+primOpTag Word2DoubleOp = 94+primOpTag ISllOp = 95+primOpTag ISraOp = 96+primOpTag ISrlOp = 97+primOpTag WordAddOp = 98+primOpTag WordAddCOp = 99+primOpTag WordSubCOp = 100+primOpTag WordAdd2Op = 101+primOpTag WordSubOp = 102+primOpTag WordMulOp = 103+primOpTag WordMul2Op = 104+primOpTag WordQuotOp = 105+primOpTag WordRemOp = 106+primOpTag WordQuotRemOp = 107+primOpTag WordQuotRem2Op = 108+primOpTag AndOp = 109+primOpTag OrOp = 110+primOpTag XorOp = 111+primOpTag NotOp = 112+primOpTag SllOp = 113+primOpTag SrlOp = 114+primOpTag Word2IntOp = 115+primOpTag WordGtOp = 116+primOpTag WordGeOp = 117+primOpTag WordEqOp = 118+primOpTag WordNeOp = 119+primOpTag WordLtOp = 120+primOpTag WordLeOp = 121+primOpTag PopCnt8Op = 122+primOpTag PopCnt16Op = 123+primOpTag PopCnt32Op = 124+primOpTag PopCnt64Op = 125+primOpTag PopCntOp = 126+primOpTag Pdep8Op = 127+primOpTag Pdep16Op = 128+primOpTag Pdep32Op = 129+primOpTag Pdep64Op = 130+primOpTag PdepOp = 131+primOpTag Pext8Op = 132+primOpTag Pext16Op = 133+primOpTag Pext32Op = 134+primOpTag Pext64Op = 135+primOpTag PextOp = 136+primOpTag Clz8Op = 137+primOpTag Clz16Op = 138+primOpTag Clz32Op = 139+primOpTag Clz64Op = 140+primOpTag ClzOp = 141+primOpTag Ctz8Op = 142+primOpTag Ctz16Op = 143+primOpTag Ctz32Op = 144+primOpTag Ctz64Op = 145+primOpTag CtzOp = 146+primOpTag BSwap16Op = 147+primOpTag BSwap32Op = 148+primOpTag BSwap64Op = 149+primOpTag BSwapOp = 150+primOpTag BRev8Op = 151+primOpTag BRev16Op = 152+primOpTag BRev32Op = 153+primOpTag BRev64Op = 154+primOpTag BRevOp = 155+primOpTag Narrow8IntOp = 156+primOpTag Narrow16IntOp = 157+primOpTag Narrow32IntOp = 158+primOpTag Narrow8WordOp = 159+primOpTag Narrow16WordOp = 160+primOpTag Narrow32WordOp = 161+primOpTag DoubleGtOp = 162+primOpTag DoubleGeOp = 163+primOpTag DoubleEqOp = 164+primOpTag DoubleNeOp = 165+primOpTag DoubleLtOp = 166+primOpTag DoubleLeOp = 167+primOpTag DoubleAddOp = 168+primOpTag DoubleSubOp = 169+primOpTag DoubleMulOp = 170+primOpTag DoubleDivOp = 171+primOpTag DoubleNegOp = 172+primOpTag DoubleFabsOp = 173+primOpTag Double2IntOp = 174+primOpTag Double2FloatOp = 175+primOpTag DoubleExpOp = 176+primOpTag DoubleExpM1Op = 177+primOpTag DoubleLogOp = 178+primOpTag DoubleLog1POp = 179+primOpTag DoubleSqrtOp = 180+primOpTag DoubleSinOp = 181+primOpTag DoubleCosOp = 182+primOpTag DoubleTanOp = 183+primOpTag DoubleAsinOp = 184+primOpTag DoubleAcosOp = 185+primOpTag DoubleAtanOp = 186+primOpTag DoubleSinhOp = 187+primOpTag DoubleCoshOp = 188+primOpTag DoubleTanhOp = 189+primOpTag DoubleAsinhOp = 190+primOpTag DoubleAcoshOp = 191+primOpTag DoubleAtanhOp = 192+primOpTag DoublePowerOp = 193+primOpTag DoubleDecode_2IntOp = 194+primOpTag DoubleDecode_Int64Op = 195+primOpTag FloatGtOp = 196+primOpTag FloatGeOp = 197+primOpTag FloatEqOp = 198+primOpTag FloatNeOp = 199+primOpTag FloatLtOp = 200+primOpTag FloatLeOp = 201+primOpTag FloatAddOp = 202+primOpTag FloatSubOp = 203+primOpTag FloatMulOp = 204+primOpTag FloatDivOp = 205+primOpTag FloatNegOp = 206+primOpTag FloatFabsOp = 207+primOpTag Float2IntOp = 208+primOpTag FloatExpOp = 209+primOpTag FloatExpM1Op = 210+primOpTag FloatLogOp = 211+primOpTag FloatLog1POp = 212+primOpTag FloatSqrtOp = 213+primOpTag FloatSinOp = 214+primOpTag FloatCosOp = 215+primOpTag FloatTanOp = 216+primOpTag FloatAsinOp = 217+primOpTag FloatAcosOp = 218+primOpTag FloatAtanOp = 219+primOpTag FloatSinhOp = 220+primOpTag FloatCoshOp = 221+primOpTag FloatTanhOp = 222+primOpTag FloatAsinhOp = 223+primOpTag FloatAcoshOp = 224+primOpTag FloatAtanhOp = 225+primOpTag FloatPowerOp = 226+primOpTag Float2DoubleOp = 227+primOpTag FloatDecode_IntOp = 228+primOpTag NewArrayOp = 229+primOpTag SameMutableArrayOp = 230+primOpTag ReadArrayOp = 231+primOpTag WriteArrayOp = 232+primOpTag SizeofArrayOp = 233+primOpTag SizeofMutableArrayOp = 234+primOpTag IndexArrayOp = 235+primOpTag UnsafeFreezeArrayOp = 236+primOpTag UnsafeThawArrayOp = 237+primOpTag CopyArrayOp = 238+primOpTag CopyMutableArrayOp = 239+primOpTag CloneArrayOp = 240+primOpTag CloneMutableArrayOp = 241+primOpTag FreezeArrayOp = 242+primOpTag ThawArrayOp = 243+primOpTag CasArrayOp = 244+primOpTag NewSmallArrayOp = 245+primOpTag SameSmallMutableArrayOp = 246+primOpTag ShrinkSmallMutableArrayOp_Char = 247+primOpTag ReadSmallArrayOp = 248+primOpTag WriteSmallArrayOp = 249+primOpTag SizeofSmallArrayOp = 250+primOpTag SizeofSmallMutableArrayOp = 251+primOpTag GetSizeofSmallMutableArrayOp = 252+primOpTag IndexSmallArrayOp = 253+primOpTag UnsafeFreezeSmallArrayOp = 254+primOpTag UnsafeThawSmallArrayOp = 255+primOpTag CopySmallArrayOp = 256+primOpTag CopySmallMutableArrayOp = 257+primOpTag CloneSmallArrayOp = 258+primOpTag CloneSmallMutableArrayOp = 259+primOpTag FreezeSmallArrayOp = 260+primOpTag ThawSmallArrayOp = 261+primOpTag CasSmallArrayOp = 262+primOpTag NewByteArrayOp_Char = 263+primOpTag NewPinnedByteArrayOp_Char = 264+primOpTag NewAlignedPinnedByteArrayOp_Char = 265+primOpTag MutableByteArrayIsPinnedOp = 266+primOpTag ByteArrayIsPinnedOp = 267+primOpTag ByteArrayContents_Char = 268+primOpTag SameMutableByteArrayOp = 269+primOpTag ShrinkMutableByteArrayOp_Char = 270+primOpTag ResizeMutableByteArrayOp_Char = 271+primOpTag UnsafeFreezeByteArrayOp = 272+primOpTag SizeofByteArrayOp = 273+primOpTag SizeofMutableByteArrayOp = 274+primOpTag GetSizeofMutableByteArrayOp = 275+primOpTag IndexByteArrayOp_Char = 276+primOpTag IndexByteArrayOp_WideChar = 277+primOpTag IndexByteArrayOp_Int = 278+primOpTag IndexByteArrayOp_Word = 279+primOpTag IndexByteArrayOp_Addr = 280+primOpTag IndexByteArrayOp_Float = 281+primOpTag IndexByteArrayOp_Double = 282+primOpTag IndexByteArrayOp_StablePtr = 283+primOpTag IndexByteArrayOp_Int8 = 284+primOpTag IndexByteArrayOp_Int16 = 285+primOpTag IndexByteArrayOp_Int32 = 286+primOpTag IndexByteArrayOp_Int64 = 287+primOpTag IndexByteArrayOp_Word8 = 288+primOpTag IndexByteArrayOp_Word16 = 289+primOpTag IndexByteArrayOp_Word32 = 290+primOpTag IndexByteArrayOp_Word64 = 291+primOpTag IndexByteArrayOp_Word8AsChar = 292+primOpTag IndexByteArrayOp_Word8AsWideChar = 293+primOpTag IndexByteArrayOp_Word8AsAddr = 294+primOpTag IndexByteArrayOp_Word8AsFloat = 295+primOpTag IndexByteArrayOp_Word8AsDouble = 296+primOpTag IndexByteArrayOp_Word8AsStablePtr = 297+primOpTag IndexByteArrayOp_Word8AsInt16 = 298+primOpTag IndexByteArrayOp_Word8AsInt32 = 299+primOpTag IndexByteArrayOp_Word8AsInt64 = 300+primOpTag IndexByteArrayOp_Word8AsInt = 301+primOpTag IndexByteArrayOp_Word8AsWord16 = 302+primOpTag IndexByteArrayOp_Word8AsWord32 = 303+primOpTag IndexByteArrayOp_Word8AsWord64 = 304+primOpTag IndexByteArrayOp_Word8AsWord = 305+primOpTag ReadByteArrayOp_Char = 306+primOpTag ReadByteArrayOp_WideChar = 307+primOpTag ReadByteArrayOp_Int = 308+primOpTag ReadByteArrayOp_Word = 309+primOpTag ReadByteArrayOp_Addr = 310+primOpTag ReadByteArrayOp_Float = 311+primOpTag ReadByteArrayOp_Double = 312+primOpTag ReadByteArrayOp_StablePtr = 313+primOpTag ReadByteArrayOp_Int8 = 314+primOpTag ReadByteArrayOp_Int16 = 315+primOpTag ReadByteArrayOp_Int32 = 316+primOpTag ReadByteArrayOp_Int64 = 317+primOpTag ReadByteArrayOp_Word8 = 318+primOpTag ReadByteArrayOp_Word16 = 319+primOpTag ReadByteArrayOp_Word32 = 320+primOpTag ReadByteArrayOp_Word64 = 321+primOpTag ReadByteArrayOp_Word8AsChar = 322+primOpTag ReadByteArrayOp_Word8AsWideChar = 323+primOpTag ReadByteArrayOp_Word8AsAddr = 324+primOpTag ReadByteArrayOp_Word8AsFloat = 325+primOpTag ReadByteArrayOp_Word8AsDouble = 326+primOpTag ReadByteArrayOp_Word8AsStablePtr = 327+primOpTag ReadByteArrayOp_Word8AsInt16 = 328+primOpTag ReadByteArrayOp_Word8AsInt32 = 329+primOpTag ReadByteArrayOp_Word8AsInt64 = 330+primOpTag ReadByteArrayOp_Word8AsInt = 331+primOpTag ReadByteArrayOp_Word8AsWord16 = 332+primOpTag ReadByteArrayOp_Word8AsWord32 = 333+primOpTag ReadByteArrayOp_Word8AsWord64 = 334+primOpTag ReadByteArrayOp_Word8AsWord = 335+primOpTag WriteByteArrayOp_Char = 336+primOpTag WriteByteArrayOp_WideChar = 337+primOpTag WriteByteArrayOp_Int = 338+primOpTag WriteByteArrayOp_Word = 339+primOpTag WriteByteArrayOp_Addr = 340+primOpTag WriteByteArrayOp_Float = 341+primOpTag WriteByteArrayOp_Double = 342+primOpTag WriteByteArrayOp_StablePtr = 343+primOpTag WriteByteArrayOp_Int8 = 344+primOpTag WriteByteArrayOp_Int16 = 345+primOpTag WriteByteArrayOp_Int32 = 346+primOpTag WriteByteArrayOp_Int64 = 347+primOpTag WriteByteArrayOp_Word8 = 348+primOpTag WriteByteArrayOp_Word16 = 349+primOpTag WriteByteArrayOp_Word32 = 350+primOpTag WriteByteArrayOp_Word64 = 351+primOpTag WriteByteArrayOp_Word8AsChar = 352+primOpTag WriteByteArrayOp_Word8AsWideChar = 353+primOpTag WriteByteArrayOp_Word8AsAddr = 354+primOpTag WriteByteArrayOp_Word8AsFloat = 355+primOpTag WriteByteArrayOp_Word8AsDouble = 356+primOpTag WriteByteArrayOp_Word8AsStablePtr = 357+primOpTag WriteByteArrayOp_Word8AsInt16 = 358+primOpTag WriteByteArrayOp_Word8AsInt32 = 359+primOpTag WriteByteArrayOp_Word8AsInt64 = 360+primOpTag WriteByteArrayOp_Word8AsInt = 361+primOpTag WriteByteArrayOp_Word8AsWord16 = 362+primOpTag WriteByteArrayOp_Word8AsWord32 = 363+primOpTag WriteByteArrayOp_Word8AsWord64 = 364+primOpTag WriteByteArrayOp_Word8AsWord = 365+primOpTag CompareByteArraysOp = 366+primOpTag CopyByteArrayOp = 367+primOpTag CopyMutableByteArrayOp = 368+primOpTag CopyByteArrayToAddrOp = 369+primOpTag CopyMutableByteArrayToAddrOp = 370+primOpTag CopyAddrToByteArrayOp = 371+primOpTag SetByteArrayOp = 372+primOpTag AtomicReadByteArrayOp_Int = 373+primOpTag AtomicWriteByteArrayOp_Int = 374+primOpTag CasByteArrayOp_Int = 375+primOpTag FetchAddByteArrayOp_Int = 376+primOpTag FetchSubByteArrayOp_Int = 377+primOpTag FetchAndByteArrayOp_Int = 378+primOpTag FetchNandByteArrayOp_Int = 379+primOpTag FetchOrByteArrayOp_Int = 380+primOpTag FetchXorByteArrayOp_Int = 381+primOpTag NewArrayArrayOp = 382+primOpTag SameMutableArrayArrayOp = 383+primOpTag UnsafeFreezeArrayArrayOp = 384+primOpTag SizeofArrayArrayOp = 385+primOpTag SizeofMutableArrayArrayOp = 386+primOpTag IndexArrayArrayOp_ByteArray = 387+primOpTag IndexArrayArrayOp_ArrayArray = 388+primOpTag ReadArrayArrayOp_ByteArray = 389+primOpTag ReadArrayArrayOp_MutableByteArray = 390+primOpTag ReadArrayArrayOp_ArrayArray = 391+primOpTag ReadArrayArrayOp_MutableArrayArray = 392+primOpTag WriteArrayArrayOp_ByteArray = 393+primOpTag WriteArrayArrayOp_MutableByteArray = 394+primOpTag WriteArrayArrayOp_ArrayArray = 395+primOpTag WriteArrayArrayOp_MutableArrayArray = 396+primOpTag CopyArrayArrayOp = 397+primOpTag CopyMutableArrayArrayOp = 398+primOpTag AddrAddOp = 399+primOpTag AddrSubOp = 400+primOpTag AddrRemOp = 401+primOpTag Addr2IntOp = 402+primOpTag Int2AddrOp = 403+primOpTag AddrGtOp = 404+primOpTag AddrGeOp = 405+primOpTag AddrEqOp = 406+primOpTag AddrNeOp = 407+primOpTag AddrLtOp = 408+primOpTag AddrLeOp = 409+primOpTag IndexOffAddrOp_Char = 410+primOpTag IndexOffAddrOp_WideChar = 411+primOpTag IndexOffAddrOp_Int = 412+primOpTag IndexOffAddrOp_Word = 413+primOpTag IndexOffAddrOp_Addr = 414+primOpTag IndexOffAddrOp_Float = 415+primOpTag IndexOffAddrOp_Double = 416+primOpTag IndexOffAddrOp_StablePtr = 417+primOpTag IndexOffAddrOp_Int8 = 418+primOpTag IndexOffAddrOp_Int16 = 419+primOpTag IndexOffAddrOp_Int32 = 420+primOpTag IndexOffAddrOp_Int64 = 421+primOpTag IndexOffAddrOp_Word8 = 422+primOpTag IndexOffAddrOp_Word16 = 423+primOpTag IndexOffAddrOp_Word32 = 424+primOpTag IndexOffAddrOp_Word64 = 425+primOpTag ReadOffAddrOp_Char = 426+primOpTag ReadOffAddrOp_WideChar = 427+primOpTag ReadOffAddrOp_Int = 428+primOpTag ReadOffAddrOp_Word = 429+primOpTag ReadOffAddrOp_Addr = 430+primOpTag ReadOffAddrOp_Float = 431+primOpTag ReadOffAddrOp_Double = 432+primOpTag ReadOffAddrOp_StablePtr = 433+primOpTag ReadOffAddrOp_Int8 = 434+primOpTag ReadOffAddrOp_Int16 = 435+primOpTag ReadOffAddrOp_Int32 = 436+primOpTag ReadOffAddrOp_Int64 = 437+primOpTag ReadOffAddrOp_Word8 = 438+primOpTag ReadOffAddrOp_Word16 = 439+primOpTag ReadOffAddrOp_Word32 = 440+primOpTag ReadOffAddrOp_Word64 = 441+primOpTag WriteOffAddrOp_Char = 442+primOpTag WriteOffAddrOp_WideChar = 443+primOpTag WriteOffAddrOp_Int = 444+primOpTag WriteOffAddrOp_Word = 445+primOpTag WriteOffAddrOp_Addr = 446+primOpTag WriteOffAddrOp_Float = 447+primOpTag WriteOffAddrOp_Double = 448+primOpTag WriteOffAddrOp_StablePtr = 449+primOpTag WriteOffAddrOp_Int8 = 450+primOpTag WriteOffAddrOp_Int16 = 451+primOpTag WriteOffAddrOp_Int32 = 452+primOpTag WriteOffAddrOp_Int64 = 453+primOpTag WriteOffAddrOp_Word8 = 454+primOpTag WriteOffAddrOp_Word16 = 455+primOpTag WriteOffAddrOp_Word32 = 456+primOpTag WriteOffAddrOp_Word64 = 457+primOpTag NewMutVarOp = 458+primOpTag ReadMutVarOp = 459+primOpTag WriteMutVarOp = 460+primOpTag SameMutVarOp = 461+primOpTag AtomicModifyMutVar2Op = 462+primOpTag AtomicModifyMutVar_Op = 463+primOpTag CasMutVarOp = 464+primOpTag CatchOp = 465+primOpTag RaiseOp = 466+primOpTag RaiseDivZeroOp = 467+primOpTag RaiseUnderflowOp = 468+primOpTag RaiseOverflowOp = 469+primOpTag RaiseIOOp = 470+primOpTag MaskAsyncExceptionsOp = 471+primOpTag MaskUninterruptibleOp = 472+primOpTag UnmaskAsyncExceptionsOp = 473+primOpTag MaskStatus = 474+primOpTag AtomicallyOp = 475+primOpTag RetryOp = 476+primOpTag CatchRetryOp = 477+primOpTag CatchSTMOp = 478+primOpTag NewTVarOp = 479+primOpTag ReadTVarOp = 480+primOpTag ReadTVarIOOp = 481+primOpTag WriteTVarOp = 482+primOpTag SameTVarOp = 483+primOpTag NewMVarOp = 484+primOpTag TakeMVarOp = 485+primOpTag TryTakeMVarOp = 486+primOpTag PutMVarOp = 487+primOpTag TryPutMVarOp = 488+primOpTag ReadMVarOp = 489+primOpTag TryReadMVarOp = 490+primOpTag SameMVarOp = 491+primOpTag IsEmptyMVarOp = 492+primOpTag DelayOp = 493+primOpTag WaitReadOp = 494+primOpTag WaitWriteOp = 495+primOpTag ForkOp = 496+primOpTag ForkOnOp = 497+primOpTag KillThreadOp = 498+primOpTag YieldOp = 499+primOpTag MyThreadIdOp = 500+primOpTag LabelThreadOp = 501+primOpTag IsCurrentThreadBoundOp = 502+primOpTag NoDuplicateOp = 503+primOpTag ThreadStatusOp = 504+primOpTag MkWeakOp = 505+primOpTag MkWeakNoFinalizerOp = 506+primOpTag AddCFinalizerToWeakOp = 507+primOpTag DeRefWeakOp = 508+primOpTag FinalizeWeakOp = 509+primOpTag TouchOp = 510+primOpTag MakeStablePtrOp = 511+primOpTag DeRefStablePtrOp = 512+primOpTag EqStablePtrOp = 513+primOpTag MakeStableNameOp = 514+primOpTag EqStableNameOp = 515+primOpTag StableNameToIntOp = 516+primOpTag CompactNewOp = 517+primOpTag CompactResizeOp = 518+primOpTag CompactContainsOp = 519+primOpTag CompactContainsAnyOp = 520+primOpTag CompactGetFirstBlockOp = 521+primOpTag CompactGetNextBlockOp = 522+primOpTag CompactAllocateBlockOp = 523+primOpTag CompactFixupPointersOp = 524+primOpTag CompactAdd = 525+primOpTag CompactAddWithSharing = 526+primOpTag CompactSize = 527+primOpTag ReallyUnsafePtrEqualityOp = 528+primOpTag ParOp = 529+primOpTag SparkOp = 530+primOpTag SeqOp = 531+primOpTag GetSparkOp = 532+primOpTag NumSparks = 533+primOpTag DataToTagOp = 534+primOpTag TagToEnumOp = 535+primOpTag AddrToAnyOp = 536+primOpTag AnyToAddrOp = 537+primOpTag MkApUpd0_Op = 538+primOpTag NewBCOOp = 539+primOpTag UnpackClosureOp = 540+primOpTag ClosureSizeOp = 541+primOpTag GetApStackValOp = 542+primOpTag GetCCSOfOp = 543+primOpTag GetCurrentCCSOp = 544+primOpTag ClearCCSOp = 545+primOpTag TraceEventOp = 546+primOpTag TraceEventBinaryOp = 547+primOpTag TraceMarkerOp = 548+primOpTag SetThreadAllocationCounter = 549+primOpTag (VecBroadcastOp IntVec 16 W8) = 550+primOpTag (VecBroadcastOp IntVec 8 W16) = 551+primOpTag (VecBroadcastOp IntVec 4 W32) = 552+primOpTag (VecBroadcastOp IntVec 2 W64) = 553+primOpTag (VecBroadcastOp IntVec 32 W8) = 554+primOpTag (VecBroadcastOp IntVec 16 W16) = 555+primOpTag (VecBroadcastOp IntVec 8 W32) = 556+primOpTag (VecBroadcastOp IntVec 4 W64) = 557+primOpTag (VecBroadcastOp IntVec 64 W8) = 558+primOpTag (VecBroadcastOp IntVec 32 W16) = 559+primOpTag (VecBroadcastOp IntVec 16 W32) = 560+primOpTag (VecBroadcastOp IntVec 8 W64) = 561+primOpTag (VecBroadcastOp WordVec 16 W8) = 562+primOpTag (VecBroadcastOp WordVec 8 W16) = 563+primOpTag (VecBroadcastOp WordVec 4 W32) = 564+primOpTag (VecBroadcastOp WordVec 2 W64) = 565+primOpTag (VecBroadcastOp WordVec 32 W8) = 566+primOpTag (VecBroadcastOp WordVec 16 W16) = 567+primOpTag (VecBroadcastOp WordVec 8 W32) = 568+primOpTag (VecBroadcastOp WordVec 4 W64) = 569+primOpTag (VecBroadcastOp WordVec 64 W8) = 570+primOpTag (VecBroadcastOp WordVec 32 W16) = 571+primOpTag (VecBroadcastOp WordVec 16 W32) = 572+primOpTag (VecBroadcastOp WordVec 8 W64) = 573+primOpTag (VecBroadcastOp FloatVec 4 W32) = 574+primOpTag (VecBroadcastOp FloatVec 2 W64) = 575+primOpTag (VecBroadcastOp FloatVec 8 W32) = 576+primOpTag (VecBroadcastOp FloatVec 4 W64) = 577+primOpTag (VecBroadcastOp FloatVec 16 W32) = 578+primOpTag (VecBroadcastOp FloatVec 8 W64) = 579+primOpTag (VecPackOp IntVec 16 W8) = 580+primOpTag (VecPackOp IntVec 8 W16) = 581+primOpTag (VecPackOp IntVec 4 W32) = 582+primOpTag (VecPackOp IntVec 2 W64) = 583+primOpTag (VecPackOp IntVec 32 W8) = 584+primOpTag (VecPackOp IntVec 16 W16) = 585+primOpTag (VecPackOp IntVec 8 W32) = 586+primOpTag (VecPackOp IntVec 4 W64) = 587+primOpTag (VecPackOp IntVec 64 W8) = 588+primOpTag (VecPackOp IntVec 32 W16) = 589+primOpTag (VecPackOp IntVec 16 W32) = 590+primOpTag (VecPackOp IntVec 8 W64) = 591+primOpTag (VecPackOp WordVec 16 W8) = 592+primOpTag (VecPackOp WordVec 8 W16) = 593+primOpTag (VecPackOp WordVec 4 W32) = 594+primOpTag (VecPackOp WordVec 2 W64) = 595+primOpTag (VecPackOp WordVec 32 W8) = 596+primOpTag (VecPackOp WordVec 16 W16) = 597+primOpTag (VecPackOp WordVec 8 W32) = 598+primOpTag (VecPackOp WordVec 4 W64) = 599+primOpTag (VecPackOp WordVec 64 W8) = 600+primOpTag (VecPackOp WordVec 32 W16) = 601+primOpTag (VecPackOp WordVec 16 W32) = 602+primOpTag (VecPackOp WordVec 8 W64) = 603+primOpTag (VecPackOp FloatVec 4 W32) = 604+primOpTag (VecPackOp FloatVec 2 W64) = 605+primOpTag (VecPackOp FloatVec 8 W32) = 606+primOpTag (VecPackOp FloatVec 4 W64) = 607+primOpTag (VecPackOp FloatVec 16 W32) = 608+primOpTag (VecPackOp FloatVec 8 W64) = 609+primOpTag (VecUnpackOp IntVec 16 W8) = 610+primOpTag (VecUnpackOp IntVec 8 W16) = 611+primOpTag (VecUnpackOp IntVec 4 W32) = 612+primOpTag (VecUnpackOp IntVec 2 W64) = 613+primOpTag (VecUnpackOp IntVec 32 W8) = 614+primOpTag (VecUnpackOp IntVec 16 W16) = 615+primOpTag (VecUnpackOp IntVec 8 W32) = 616+primOpTag (VecUnpackOp IntVec 4 W64) = 617+primOpTag (VecUnpackOp IntVec 64 W8) = 618+primOpTag (VecUnpackOp IntVec 32 W16) = 619+primOpTag (VecUnpackOp IntVec 16 W32) = 620+primOpTag (VecUnpackOp IntVec 8 W64) = 621+primOpTag (VecUnpackOp WordVec 16 W8) = 622+primOpTag (VecUnpackOp WordVec 8 W16) = 623+primOpTag (VecUnpackOp WordVec 4 W32) = 624+primOpTag (VecUnpackOp WordVec 2 W64) = 625+primOpTag (VecUnpackOp WordVec 32 W8) = 626+primOpTag (VecUnpackOp WordVec 16 W16) = 627+primOpTag (VecUnpackOp WordVec 8 W32) = 628+primOpTag (VecUnpackOp WordVec 4 W64) = 629+primOpTag (VecUnpackOp WordVec 64 W8) = 630+primOpTag (VecUnpackOp WordVec 32 W16) = 631+primOpTag (VecUnpackOp WordVec 16 W32) = 632+primOpTag (VecUnpackOp WordVec 8 W64) = 633+primOpTag (VecUnpackOp FloatVec 4 W32) = 634+primOpTag (VecUnpackOp FloatVec 2 W64) = 635+primOpTag (VecUnpackOp FloatVec 8 W32) = 636+primOpTag (VecUnpackOp FloatVec 4 W64) = 637+primOpTag (VecUnpackOp FloatVec 16 W32) = 638+primOpTag (VecUnpackOp FloatVec 8 W64) = 639+primOpTag (VecInsertOp IntVec 16 W8) = 640+primOpTag (VecInsertOp IntVec 8 W16) = 641+primOpTag (VecInsertOp IntVec 4 W32) = 642+primOpTag (VecInsertOp IntVec 2 W64) = 643+primOpTag (VecInsertOp IntVec 32 W8) = 644+primOpTag (VecInsertOp IntVec 16 W16) = 645+primOpTag (VecInsertOp IntVec 8 W32) = 646+primOpTag (VecInsertOp IntVec 4 W64) = 647+primOpTag (VecInsertOp IntVec 64 W8) = 648+primOpTag (VecInsertOp IntVec 32 W16) = 649+primOpTag (VecInsertOp IntVec 16 W32) = 650+primOpTag (VecInsertOp IntVec 8 W64) = 651+primOpTag (VecInsertOp WordVec 16 W8) = 652+primOpTag (VecInsertOp WordVec 8 W16) = 653+primOpTag (VecInsertOp WordVec 4 W32) = 654+primOpTag (VecInsertOp WordVec 2 W64) = 655+primOpTag (VecInsertOp WordVec 32 W8) = 656+primOpTag (VecInsertOp WordVec 16 W16) = 657+primOpTag (VecInsertOp WordVec 8 W32) = 658+primOpTag (VecInsertOp WordVec 4 W64) = 659+primOpTag (VecInsertOp WordVec 64 W8) = 660+primOpTag (VecInsertOp WordVec 32 W16) = 661+primOpTag (VecInsertOp WordVec 16 W32) = 662+primOpTag (VecInsertOp WordVec 8 W64) = 663+primOpTag (VecInsertOp FloatVec 4 W32) = 664+primOpTag (VecInsertOp FloatVec 2 W64) = 665+primOpTag (VecInsertOp FloatVec 8 W32) = 666+primOpTag (VecInsertOp FloatVec 4 W64) = 667+primOpTag (VecInsertOp FloatVec 16 W32) = 668+primOpTag (VecInsertOp FloatVec 8 W64) = 669+primOpTag (VecAddOp IntVec 16 W8) = 670+primOpTag (VecAddOp IntVec 8 W16) = 671+primOpTag (VecAddOp IntVec 4 W32) = 672+primOpTag (VecAddOp IntVec 2 W64) = 673+primOpTag (VecAddOp IntVec 32 W8) = 674+primOpTag (VecAddOp IntVec 16 W16) = 675+primOpTag (VecAddOp IntVec 8 W32) = 676+primOpTag (VecAddOp IntVec 4 W64) = 677+primOpTag (VecAddOp IntVec 64 W8) = 678+primOpTag (VecAddOp IntVec 32 W16) = 679+primOpTag (VecAddOp IntVec 16 W32) = 680+primOpTag (VecAddOp IntVec 8 W64) = 681+primOpTag (VecAddOp WordVec 16 W8) = 682+primOpTag (VecAddOp WordVec 8 W16) = 683+primOpTag (VecAddOp WordVec 4 W32) = 684+primOpTag (VecAddOp WordVec 2 W64) = 685+primOpTag (VecAddOp WordVec 32 W8) = 686+primOpTag (VecAddOp WordVec 16 W16) = 687+primOpTag (VecAddOp WordVec 8 W32) = 688+primOpTag (VecAddOp WordVec 4 W64) = 689+primOpTag (VecAddOp WordVec 64 W8) = 690+primOpTag (VecAddOp WordVec 32 W16) = 691+primOpTag (VecAddOp WordVec 16 W32) = 692+primOpTag (VecAddOp WordVec 8 W64) = 693+primOpTag (VecAddOp FloatVec 4 W32) = 694+primOpTag (VecAddOp FloatVec 2 W64) = 695+primOpTag (VecAddOp FloatVec 8 W32) = 696+primOpTag (VecAddOp FloatVec 4 W64) = 697+primOpTag (VecAddOp FloatVec 16 W32) = 698+primOpTag (VecAddOp FloatVec 8 W64) = 699+primOpTag (VecSubOp IntVec 16 W8) = 700+primOpTag (VecSubOp IntVec 8 W16) = 701+primOpTag (VecSubOp IntVec 4 W32) = 702+primOpTag (VecSubOp IntVec 2 W64) = 703+primOpTag (VecSubOp IntVec 32 W8) = 704+primOpTag (VecSubOp IntVec 16 W16) = 705+primOpTag (VecSubOp IntVec 8 W32) = 706+primOpTag (VecSubOp IntVec 4 W64) = 707+primOpTag (VecSubOp IntVec 64 W8) = 708+primOpTag (VecSubOp IntVec 32 W16) = 709+primOpTag (VecSubOp IntVec 16 W32) = 710+primOpTag (VecSubOp IntVec 8 W64) = 711+primOpTag (VecSubOp WordVec 16 W8) = 712+primOpTag (VecSubOp WordVec 8 W16) = 713+primOpTag (VecSubOp WordVec 4 W32) = 714+primOpTag (VecSubOp WordVec 2 W64) = 715+primOpTag (VecSubOp WordVec 32 W8) = 716+primOpTag (VecSubOp WordVec 16 W16) = 717+primOpTag (VecSubOp WordVec 8 W32) = 718+primOpTag (VecSubOp WordVec 4 W64) = 719+primOpTag (VecSubOp WordVec 64 W8) = 720+primOpTag (VecSubOp WordVec 32 W16) = 721+primOpTag (VecSubOp WordVec 16 W32) = 722+primOpTag (VecSubOp WordVec 8 W64) = 723+primOpTag (VecSubOp FloatVec 4 W32) = 724+primOpTag (VecSubOp FloatVec 2 W64) = 725+primOpTag (VecSubOp FloatVec 8 W32) = 726+primOpTag (VecSubOp FloatVec 4 W64) = 727+primOpTag (VecSubOp FloatVec 16 W32) = 728+primOpTag (VecSubOp FloatVec 8 W64) = 729+primOpTag (VecMulOp IntVec 16 W8) = 730+primOpTag (VecMulOp IntVec 8 W16) = 731+primOpTag (VecMulOp IntVec 4 W32) = 732+primOpTag (VecMulOp IntVec 2 W64) = 733+primOpTag (VecMulOp IntVec 32 W8) = 734+primOpTag (VecMulOp IntVec 16 W16) = 735+primOpTag (VecMulOp IntVec 8 W32) = 736+primOpTag (VecMulOp IntVec 4 W64) = 737+primOpTag (VecMulOp IntVec 64 W8) = 738+primOpTag (VecMulOp IntVec 32 W16) = 739+primOpTag (VecMulOp IntVec 16 W32) = 740+primOpTag (VecMulOp IntVec 8 W64) = 741+primOpTag (VecMulOp WordVec 16 W8) = 742+primOpTag (VecMulOp WordVec 8 W16) = 743+primOpTag (VecMulOp WordVec 4 W32) = 744+primOpTag (VecMulOp WordVec 2 W64) = 745+primOpTag (VecMulOp WordVec 32 W8) = 746+primOpTag (VecMulOp WordVec 16 W16) = 747+primOpTag (VecMulOp WordVec 8 W32) = 748+primOpTag (VecMulOp WordVec 4 W64) = 749+primOpTag (VecMulOp WordVec 64 W8) = 750+primOpTag (VecMulOp WordVec 32 W16) = 751+primOpTag (VecMulOp WordVec 16 W32) = 752+primOpTag (VecMulOp WordVec 8 W64) = 753+primOpTag (VecMulOp FloatVec 4 W32) = 754+primOpTag (VecMulOp FloatVec 2 W64) = 755+primOpTag (VecMulOp FloatVec 8 W32) = 756+primOpTag (VecMulOp FloatVec 4 W64) = 757+primOpTag (VecMulOp FloatVec 16 W32) = 758+primOpTag (VecMulOp FloatVec 8 W64) = 759+primOpTag (VecDivOp FloatVec 4 W32) = 760+primOpTag (VecDivOp FloatVec 2 W64) = 761+primOpTag (VecDivOp FloatVec 8 W32) = 762+primOpTag (VecDivOp FloatVec 4 W64) = 763+primOpTag (VecDivOp FloatVec 16 W32) = 764+primOpTag (VecDivOp FloatVec 8 W64) = 765+primOpTag (VecQuotOp IntVec 16 W8) = 766+primOpTag (VecQuotOp IntVec 8 W16) = 767+primOpTag (VecQuotOp IntVec 4 W32) = 768+primOpTag (VecQuotOp IntVec 2 W64) = 769+primOpTag (VecQuotOp IntVec 32 W8) = 770+primOpTag (VecQuotOp IntVec 16 W16) = 771+primOpTag (VecQuotOp IntVec 8 W32) = 772+primOpTag (VecQuotOp IntVec 4 W64) = 773+primOpTag (VecQuotOp IntVec 64 W8) = 774+primOpTag (VecQuotOp IntVec 32 W16) = 775+primOpTag (VecQuotOp IntVec 16 W32) = 776+primOpTag (VecQuotOp IntVec 8 W64) = 777+primOpTag (VecQuotOp WordVec 16 W8) = 778+primOpTag (VecQuotOp WordVec 8 W16) = 779+primOpTag (VecQuotOp WordVec 4 W32) = 780+primOpTag (VecQuotOp WordVec 2 W64) = 781+primOpTag (VecQuotOp WordVec 32 W8) = 782+primOpTag (VecQuotOp WordVec 16 W16) = 783+primOpTag (VecQuotOp WordVec 8 W32) = 784+primOpTag (VecQuotOp WordVec 4 W64) = 785+primOpTag (VecQuotOp WordVec 64 W8) = 786+primOpTag (VecQuotOp WordVec 32 W16) = 787+primOpTag (VecQuotOp WordVec 16 W32) = 788+primOpTag (VecQuotOp WordVec 8 W64) = 789+primOpTag (VecRemOp IntVec 16 W8) = 790+primOpTag (VecRemOp IntVec 8 W16) = 791+primOpTag (VecRemOp IntVec 4 W32) = 792+primOpTag (VecRemOp IntVec 2 W64) = 793+primOpTag (VecRemOp IntVec 32 W8) = 794+primOpTag (VecRemOp IntVec 16 W16) = 795+primOpTag (VecRemOp IntVec 8 W32) = 796+primOpTag (VecRemOp IntVec 4 W64) = 797+primOpTag (VecRemOp IntVec 64 W8) = 798+primOpTag (VecRemOp IntVec 32 W16) = 799+primOpTag (VecRemOp IntVec 16 W32) = 800+primOpTag (VecRemOp IntVec 8 W64) = 801+primOpTag (VecRemOp WordVec 16 W8) = 802+primOpTag (VecRemOp WordVec 8 W16) = 803+primOpTag (VecRemOp WordVec 4 W32) = 804+primOpTag (VecRemOp WordVec 2 W64) = 805+primOpTag (VecRemOp WordVec 32 W8) = 806+primOpTag (VecRemOp WordVec 16 W16) = 807+primOpTag (VecRemOp WordVec 8 W32) = 808+primOpTag (VecRemOp WordVec 4 W64) = 809+primOpTag (VecRemOp WordVec 64 W8) = 810+primOpTag (VecRemOp WordVec 32 W16) = 811+primOpTag (VecRemOp WordVec 16 W32) = 812+primOpTag (VecRemOp WordVec 8 W64) = 813+primOpTag (VecNegOp IntVec 16 W8) = 814+primOpTag (VecNegOp IntVec 8 W16) = 815+primOpTag (VecNegOp IntVec 4 W32) = 816+primOpTag (VecNegOp IntVec 2 W64) = 817+primOpTag (VecNegOp IntVec 32 W8) = 818+primOpTag (VecNegOp IntVec 16 W16) = 819+primOpTag (VecNegOp IntVec 8 W32) = 820+primOpTag (VecNegOp IntVec 4 W64) = 821+primOpTag (VecNegOp IntVec 64 W8) = 822+primOpTag (VecNegOp IntVec 32 W16) = 823+primOpTag (VecNegOp IntVec 16 W32) = 824+primOpTag (VecNegOp IntVec 8 W64) = 825+primOpTag (VecNegOp FloatVec 4 W32) = 826+primOpTag (VecNegOp FloatVec 2 W64) = 827+primOpTag (VecNegOp FloatVec 8 W32) = 828+primOpTag (VecNegOp FloatVec 4 W64) = 829+primOpTag (VecNegOp FloatVec 16 W32) = 830+primOpTag (VecNegOp FloatVec 8 W64) = 831+primOpTag (VecIndexByteArrayOp IntVec 16 W8) = 832+primOpTag (VecIndexByteArrayOp IntVec 8 W16) = 833+primOpTag (VecIndexByteArrayOp IntVec 4 W32) = 834+primOpTag (VecIndexByteArrayOp IntVec 2 W64) = 835+primOpTag (VecIndexByteArrayOp IntVec 32 W8) = 836+primOpTag (VecIndexByteArrayOp IntVec 16 W16) = 837+primOpTag (VecIndexByteArrayOp IntVec 8 W32) = 838+primOpTag (VecIndexByteArrayOp IntVec 4 W64) = 839+primOpTag (VecIndexByteArrayOp IntVec 64 W8) = 840+primOpTag (VecIndexByteArrayOp IntVec 32 W16) = 841+primOpTag (VecIndexByteArrayOp IntVec 16 W32) = 842+primOpTag (VecIndexByteArrayOp IntVec 8 W64) = 843+primOpTag (VecIndexByteArrayOp WordVec 16 W8) = 844+primOpTag (VecIndexByteArrayOp WordVec 8 W16) = 845+primOpTag (VecIndexByteArrayOp WordVec 4 W32) = 846+primOpTag (VecIndexByteArrayOp WordVec 2 W64) = 847+primOpTag (VecIndexByteArrayOp WordVec 32 W8) = 848+primOpTag (VecIndexByteArrayOp WordVec 16 W16) = 849+primOpTag (VecIndexByteArrayOp WordVec 8 W32) = 850+primOpTag (VecIndexByteArrayOp WordVec 4 W64) = 851+primOpTag (VecIndexByteArrayOp WordVec 64 W8) = 852+primOpTag (VecIndexByteArrayOp WordVec 32 W16) = 853+primOpTag (VecIndexByteArrayOp WordVec 16 W32) = 854+primOpTag (VecIndexByteArrayOp WordVec 8 W64) = 855+primOpTag (VecIndexByteArrayOp FloatVec 4 W32) = 856+primOpTag (VecIndexByteArrayOp FloatVec 2 W64) = 857+primOpTag (VecIndexByteArrayOp FloatVec 8 W32) = 858+primOpTag (VecIndexByteArrayOp FloatVec 4 W64) = 859+primOpTag (VecIndexByteArrayOp FloatVec 16 W32) = 860+primOpTag (VecIndexByteArrayOp FloatVec 8 W64) = 861+primOpTag (VecReadByteArrayOp IntVec 16 W8) = 862+primOpTag (VecReadByteArrayOp IntVec 8 W16) = 863+primOpTag (VecReadByteArrayOp IntVec 4 W32) = 864+primOpTag (VecReadByteArrayOp IntVec 2 W64) = 865+primOpTag (VecReadByteArrayOp IntVec 32 W8) = 866+primOpTag (VecReadByteArrayOp IntVec 16 W16) = 867+primOpTag (VecReadByteArrayOp IntVec 8 W32) = 868+primOpTag (VecReadByteArrayOp IntVec 4 W64) = 869+primOpTag (VecReadByteArrayOp IntVec 64 W8) = 870+primOpTag (VecReadByteArrayOp IntVec 32 W16) = 871+primOpTag (VecReadByteArrayOp IntVec 16 W32) = 872+primOpTag (VecReadByteArrayOp IntVec 8 W64) = 873+primOpTag (VecReadByteArrayOp WordVec 16 W8) = 874+primOpTag (VecReadByteArrayOp WordVec 8 W16) = 875+primOpTag (VecReadByteArrayOp WordVec 4 W32) = 876+primOpTag (VecReadByteArrayOp WordVec 2 W64) = 877+primOpTag (VecReadByteArrayOp WordVec 32 W8) = 878+primOpTag (VecReadByteArrayOp WordVec 16 W16) = 879+primOpTag (VecReadByteArrayOp WordVec 8 W32) = 880+primOpTag (VecReadByteArrayOp WordVec 4 W64) = 881+primOpTag (VecReadByteArrayOp WordVec 64 W8) = 882+primOpTag (VecReadByteArrayOp WordVec 32 W16) = 883+primOpTag (VecReadByteArrayOp WordVec 16 W32) = 884+primOpTag (VecReadByteArrayOp WordVec 8 W64) = 885+primOpTag (VecReadByteArrayOp FloatVec 4 W32) = 886+primOpTag (VecReadByteArrayOp FloatVec 2 W64) = 887+primOpTag (VecReadByteArrayOp FloatVec 8 W32) = 888+primOpTag (VecReadByteArrayOp FloatVec 4 W64) = 889+primOpTag (VecReadByteArrayOp FloatVec 16 W32) = 890+primOpTag (VecReadByteArrayOp FloatVec 8 W64) = 891+primOpTag (VecWriteByteArrayOp IntVec 16 W8) = 892+primOpTag (VecWriteByteArrayOp IntVec 8 W16) = 893+primOpTag (VecWriteByteArrayOp IntVec 4 W32) = 894+primOpTag (VecWriteByteArrayOp IntVec 2 W64) = 895+primOpTag (VecWriteByteArrayOp IntVec 32 W8) = 896+primOpTag (VecWriteByteArrayOp IntVec 16 W16) = 897+primOpTag (VecWriteByteArrayOp IntVec 8 W32) = 898+primOpTag (VecWriteByteArrayOp IntVec 4 W64) = 899+primOpTag (VecWriteByteArrayOp IntVec 64 W8) = 900+primOpTag (VecWriteByteArrayOp IntVec 32 W16) = 901+primOpTag (VecWriteByteArrayOp IntVec 16 W32) = 902+primOpTag (VecWriteByteArrayOp IntVec 8 W64) = 903+primOpTag (VecWriteByteArrayOp WordVec 16 W8) = 904+primOpTag (VecWriteByteArrayOp WordVec 8 W16) = 905+primOpTag (VecWriteByteArrayOp WordVec 4 W32) = 906+primOpTag (VecWriteByteArrayOp WordVec 2 W64) = 907+primOpTag (VecWriteByteArrayOp WordVec 32 W8) = 908+primOpTag (VecWriteByteArrayOp WordVec 16 W16) = 909+primOpTag (VecWriteByteArrayOp WordVec 8 W32) = 910+primOpTag (VecWriteByteArrayOp WordVec 4 W64) = 911+primOpTag (VecWriteByteArrayOp WordVec 64 W8) = 912+primOpTag (VecWriteByteArrayOp WordVec 32 W16) = 913+primOpTag (VecWriteByteArrayOp WordVec 16 W32) = 914+primOpTag (VecWriteByteArrayOp WordVec 8 W64) = 915+primOpTag (VecWriteByteArrayOp FloatVec 4 W32) = 916+primOpTag (VecWriteByteArrayOp FloatVec 2 W64) = 917+primOpTag (VecWriteByteArrayOp FloatVec 8 W32) = 918+primOpTag (VecWriteByteArrayOp FloatVec 4 W64) = 919+primOpTag (VecWriteByteArrayOp FloatVec 16 W32) = 920+primOpTag (VecWriteByteArrayOp FloatVec 8 W64) = 921+primOpTag (VecIndexOffAddrOp IntVec 16 W8) = 922+primOpTag (VecIndexOffAddrOp IntVec 8 W16) = 923+primOpTag (VecIndexOffAddrOp IntVec 4 W32) = 924+primOpTag (VecIndexOffAddrOp IntVec 2 W64) = 925+primOpTag (VecIndexOffAddrOp IntVec 32 W8) = 926+primOpTag (VecIndexOffAddrOp IntVec 16 W16) = 927+primOpTag (VecIndexOffAddrOp IntVec 8 W32) = 928+primOpTag (VecIndexOffAddrOp IntVec 4 W64) = 929+primOpTag (VecIndexOffAddrOp IntVec 64 W8) = 930+primOpTag (VecIndexOffAddrOp IntVec 32 W16) = 931+primOpTag (VecIndexOffAddrOp IntVec 16 W32) = 932+primOpTag (VecIndexOffAddrOp IntVec 8 W64) = 933+primOpTag (VecIndexOffAddrOp WordVec 16 W8) = 934+primOpTag (VecIndexOffAddrOp WordVec 8 W16) = 935+primOpTag (VecIndexOffAddrOp WordVec 4 W32) = 936+primOpTag (VecIndexOffAddrOp WordVec 2 W64) = 937+primOpTag (VecIndexOffAddrOp WordVec 32 W8) = 938+primOpTag (VecIndexOffAddrOp WordVec 16 W16) = 939+primOpTag (VecIndexOffAddrOp WordVec 8 W32) = 940+primOpTag (VecIndexOffAddrOp WordVec 4 W64) = 941+primOpTag (VecIndexOffAddrOp WordVec 64 W8) = 942+primOpTag (VecIndexOffAddrOp WordVec 32 W16) = 943+primOpTag (VecIndexOffAddrOp WordVec 16 W32) = 944+primOpTag (VecIndexOffAddrOp WordVec 8 W64) = 945+primOpTag (VecIndexOffAddrOp FloatVec 4 W32) = 946+primOpTag (VecIndexOffAddrOp FloatVec 2 W64) = 947+primOpTag (VecIndexOffAddrOp FloatVec 8 W32) = 948+primOpTag (VecIndexOffAddrOp FloatVec 4 W64) = 949+primOpTag (VecIndexOffAddrOp FloatVec 16 W32) = 950+primOpTag (VecIndexOffAddrOp FloatVec 8 W64) = 951+primOpTag (VecReadOffAddrOp IntVec 16 W8) = 952+primOpTag (VecReadOffAddrOp IntVec 8 W16) = 953+primOpTag (VecReadOffAddrOp IntVec 4 W32) = 954+primOpTag (VecReadOffAddrOp IntVec 2 W64) = 955+primOpTag (VecReadOffAddrOp IntVec 32 W8) = 956+primOpTag (VecReadOffAddrOp IntVec 16 W16) = 957+primOpTag (VecReadOffAddrOp IntVec 8 W32) = 958+primOpTag (VecReadOffAddrOp IntVec 4 W64) = 959+primOpTag (VecReadOffAddrOp IntVec 64 W8) = 960+primOpTag (VecReadOffAddrOp IntVec 32 W16) = 961+primOpTag (VecReadOffAddrOp IntVec 16 W32) = 962+primOpTag (VecReadOffAddrOp IntVec 8 W64) = 963+primOpTag (VecReadOffAddrOp WordVec 16 W8) = 964+primOpTag (VecReadOffAddrOp WordVec 8 W16) = 965+primOpTag (VecReadOffAddrOp WordVec 4 W32) = 966+primOpTag (VecReadOffAddrOp WordVec 2 W64) = 967+primOpTag (VecReadOffAddrOp WordVec 32 W8) = 968+primOpTag (VecReadOffAddrOp WordVec 16 W16) = 969+primOpTag (VecReadOffAddrOp WordVec 8 W32) = 970+primOpTag (VecReadOffAddrOp WordVec 4 W64) = 971+primOpTag (VecReadOffAddrOp WordVec 64 W8) = 972+primOpTag (VecReadOffAddrOp WordVec 32 W16) = 973+primOpTag (VecReadOffAddrOp WordVec 16 W32) = 974+primOpTag (VecReadOffAddrOp WordVec 8 W64) = 975+primOpTag (VecReadOffAddrOp FloatVec 4 W32) = 976+primOpTag (VecReadOffAddrOp FloatVec 2 W64) = 977+primOpTag (VecReadOffAddrOp FloatVec 8 W32) = 978+primOpTag (VecReadOffAddrOp FloatVec 4 W64) = 979+primOpTag (VecReadOffAddrOp FloatVec 16 W32) = 980+primOpTag (VecReadOffAddrOp FloatVec 8 W64) = 981+primOpTag (VecWriteOffAddrOp IntVec 16 W8) = 982+primOpTag (VecWriteOffAddrOp IntVec 8 W16) = 983+primOpTag (VecWriteOffAddrOp IntVec 4 W32) = 984+primOpTag (VecWriteOffAddrOp IntVec 2 W64) = 985+primOpTag (VecWriteOffAddrOp IntVec 32 W8) = 986+primOpTag (VecWriteOffAddrOp IntVec 16 W16) = 987+primOpTag (VecWriteOffAddrOp IntVec 8 W32) = 988+primOpTag (VecWriteOffAddrOp IntVec 4 W64) = 989+primOpTag (VecWriteOffAddrOp IntVec 64 W8) = 990+primOpTag (VecWriteOffAddrOp IntVec 32 W16) = 991+primOpTag (VecWriteOffAddrOp IntVec 16 W32) = 992+primOpTag (VecWriteOffAddrOp IntVec 8 W64) = 993+primOpTag (VecWriteOffAddrOp WordVec 16 W8) = 994+primOpTag (VecWriteOffAddrOp WordVec 8 W16) = 995+primOpTag (VecWriteOffAddrOp WordVec 4 W32) = 996+primOpTag (VecWriteOffAddrOp WordVec 2 W64) = 997+primOpTag (VecWriteOffAddrOp WordVec 32 W8) = 998+primOpTag (VecWriteOffAddrOp WordVec 16 W16) = 999+primOpTag (VecWriteOffAddrOp WordVec 8 W32) = 1000+primOpTag (VecWriteOffAddrOp WordVec 4 W64) = 1001+primOpTag (VecWriteOffAddrOp WordVec 64 W8) = 1002+primOpTag (VecWriteOffAddrOp WordVec 32 W16) = 1003+primOpTag (VecWriteOffAddrOp WordVec 16 W32) = 1004+primOpTag (VecWriteOffAddrOp WordVec 8 W64) = 1005+primOpTag (VecWriteOffAddrOp FloatVec 4 W32) = 1006+primOpTag (VecWriteOffAddrOp FloatVec 2 W64) = 1007+primOpTag (VecWriteOffAddrOp FloatVec 8 W32) = 1008+primOpTag (VecWriteOffAddrOp FloatVec 4 W64) = 1009+primOpTag (VecWriteOffAddrOp FloatVec 16 W32) = 1010+primOpTag (VecWriteOffAddrOp FloatVec 8 W64) = 1011+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W8) = 1012+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W16) = 1013+primOpTag (VecIndexScalarByteArrayOp IntVec 4 W32) = 1014+primOpTag (VecIndexScalarByteArrayOp IntVec 2 W64) = 1015+primOpTag (VecIndexScalarByteArrayOp IntVec 32 W8) = 1016+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W16) = 1017+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W32) = 1018+primOpTag (VecIndexScalarByteArrayOp IntVec 4 W64) = 1019+primOpTag (VecIndexScalarByteArrayOp IntVec 64 W8) = 1020+primOpTag (VecIndexScalarByteArrayOp IntVec 32 W16) = 1021+primOpTag (VecIndexScalarByteArrayOp IntVec 16 W32) = 1022+primOpTag (VecIndexScalarByteArrayOp IntVec 8 W64) = 1023+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W8) = 1024+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W16) = 1025+primOpTag (VecIndexScalarByteArrayOp WordVec 4 W32) = 1026+primOpTag (VecIndexScalarByteArrayOp WordVec 2 W64) = 1027+primOpTag (VecIndexScalarByteArrayOp WordVec 32 W8) = 1028+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W16) = 1029+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W32) = 1030+primOpTag (VecIndexScalarByteArrayOp WordVec 4 W64) = 1031+primOpTag (VecIndexScalarByteArrayOp WordVec 64 W8) = 1032+primOpTag (VecIndexScalarByteArrayOp WordVec 32 W16) = 1033+primOpTag (VecIndexScalarByteArrayOp WordVec 16 W32) = 1034+primOpTag (VecIndexScalarByteArrayOp WordVec 8 W64) = 1035+primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W32) = 1036+primOpTag (VecIndexScalarByteArrayOp FloatVec 2 W64) = 1037+primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W32) = 1038+primOpTag (VecIndexScalarByteArrayOp FloatVec 4 W64) = 1039+primOpTag (VecIndexScalarByteArrayOp FloatVec 16 W32) = 1040+primOpTag (VecIndexScalarByteArrayOp FloatVec 8 W64) = 1041+primOpTag (VecReadScalarByteArrayOp IntVec 16 W8) = 1042+primOpTag (VecReadScalarByteArrayOp IntVec 8 W16) = 1043+primOpTag (VecReadScalarByteArrayOp IntVec 4 W32) = 1044+primOpTag (VecReadScalarByteArrayOp IntVec 2 W64) = 1045+primOpTag (VecReadScalarByteArrayOp IntVec 32 W8) = 1046+primOpTag (VecReadScalarByteArrayOp IntVec 16 W16) = 1047+primOpTag (VecReadScalarByteArrayOp IntVec 8 W32) = 1048+primOpTag (VecReadScalarByteArrayOp IntVec 4 W64) = 1049+primOpTag (VecReadScalarByteArrayOp IntVec 64 W8) = 1050+primOpTag (VecReadScalarByteArrayOp IntVec 32 W16) = 1051+primOpTag (VecReadScalarByteArrayOp IntVec 16 W32) = 1052+primOpTag (VecReadScalarByteArrayOp IntVec 8 W64) = 1053+primOpTag (VecReadScalarByteArrayOp WordVec 16 W8) = 1054+primOpTag (VecReadScalarByteArrayOp WordVec 8 W16) = 1055+primOpTag (VecReadScalarByteArrayOp WordVec 4 W32) = 1056+primOpTag (VecReadScalarByteArrayOp WordVec 2 W64) = 1057+primOpTag (VecReadScalarByteArrayOp WordVec 32 W8) = 1058+primOpTag (VecReadScalarByteArrayOp WordVec 16 W16) = 1059+primOpTag (VecReadScalarByteArrayOp WordVec 8 W32) = 1060+primOpTag (VecReadScalarByteArrayOp WordVec 4 W64) = 1061+primOpTag (VecReadScalarByteArrayOp WordVec 64 W8) = 1062+primOpTag (VecReadScalarByteArrayOp WordVec 32 W16) = 1063+primOpTag (VecReadScalarByteArrayOp WordVec 16 W32) = 1064+primOpTag (VecReadScalarByteArrayOp WordVec 8 W64) = 1065+primOpTag (VecReadScalarByteArrayOp FloatVec 4 W32) = 1066+primOpTag (VecReadScalarByteArrayOp FloatVec 2 W64) = 1067+primOpTag (VecReadScalarByteArrayOp FloatVec 8 W32) = 1068+primOpTag (VecReadScalarByteArrayOp FloatVec 4 W64) = 1069+primOpTag (VecReadScalarByteArrayOp FloatVec 16 W32) = 1070+primOpTag (VecReadScalarByteArrayOp FloatVec 8 W64) = 1071+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W8) = 1072+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W16) = 1073+primOpTag (VecWriteScalarByteArrayOp IntVec 4 W32) = 1074+primOpTag (VecWriteScalarByteArrayOp IntVec 2 W64) = 1075+primOpTag (VecWriteScalarByteArrayOp IntVec 32 W8) = 1076+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W16) = 1077+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W32) = 1078+primOpTag (VecWriteScalarByteArrayOp IntVec 4 W64) = 1079+primOpTag (VecWriteScalarByteArrayOp IntVec 64 W8) = 1080+primOpTag (VecWriteScalarByteArrayOp IntVec 32 W16) = 1081+primOpTag (VecWriteScalarByteArrayOp IntVec 16 W32) = 1082+primOpTag (VecWriteScalarByteArrayOp IntVec 8 W64) = 1083+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W8) = 1084+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W16) = 1085+primOpTag (VecWriteScalarByteArrayOp WordVec 4 W32) = 1086+primOpTag (VecWriteScalarByteArrayOp WordVec 2 W64) = 1087+primOpTag (VecWriteScalarByteArrayOp WordVec 32 W8) = 1088+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W16) = 1089+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W32) = 1090+primOpTag (VecWriteScalarByteArrayOp WordVec 4 W64) = 1091+primOpTag (VecWriteScalarByteArrayOp WordVec 64 W8) = 1092+primOpTag (VecWriteScalarByteArrayOp WordVec 32 W16) = 1093+primOpTag (VecWriteScalarByteArrayOp WordVec 16 W32) = 1094+primOpTag (VecWriteScalarByteArrayOp WordVec 8 W64) = 1095+primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W32) = 1096+primOpTag (VecWriteScalarByteArrayOp FloatVec 2 W64) = 1097+primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W32) = 1098+primOpTag (VecWriteScalarByteArrayOp FloatVec 4 W64) = 1099+primOpTag (VecWriteScalarByteArrayOp FloatVec 16 W32) = 1100+primOpTag (VecWriteScalarByteArrayOp FloatVec 8 W64) = 1101+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W8) = 1102+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W16) = 1103+primOpTag (VecIndexScalarOffAddrOp IntVec 4 W32) = 1104+primOpTag (VecIndexScalarOffAddrOp IntVec 2 W64) = 1105+primOpTag (VecIndexScalarOffAddrOp IntVec 32 W8) = 1106+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W16) = 1107+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W32) = 1108+primOpTag (VecIndexScalarOffAddrOp IntVec 4 W64) = 1109+primOpTag (VecIndexScalarOffAddrOp IntVec 64 W8) = 1110+primOpTag (VecIndexScalarOffAddrOp IntVec 32 W16) = 1111+primOpTag (VecIndexScalarOffAddrOp IntVec 16 W32) = 1112+primOpTag (VecIndexScalarOffAddrOp IntVec 8 W64) = 1113+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W8) = 1114+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W16) = 1115+primOpTag (VecIndexScalarOffAddrOp WordVec 4 W32) = 1116+primOpTag (VecIndexScalarOffAddrOp WordVec 2 W64) = 1117+primOpTag (VecIndexScalarOffAddrOp WordVec 32 W8) = 1118+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W16) = 1119+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W32) = 1120+primOpTag (VecIndexScalarOffAddrOp WordVec 4 W64) = 1121+primOpTag (VecIndexScalarOffAddrOp WordVec 64 W8) = 1122+primOpTag (VecIndexScalarOffAddrOp WordVec 32 W16) = 1123+primOpTag (VecIndexScalarOffAddrOp WordVec 16 W32) = 1124+primOpTag (VecIndexScalarOffAddrOp WordVec 8 W64) = 1125+primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W32) = 1126+primOpTag (VecIndexScalarOffAddrOp FloatVec 2 W64) = 1127+primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W32) = 1128+primOpTag (VecIndexScalarOffAddrOp FloatVec 4 W64) = 1129+primOpTag (VecIndexScalarOffAddrOp FloatVec 16 W32) = 1130+primOpTag (VecIndexScalarOffAddrOp FloatVec 8 W64) = 1131+primOpTag (VecReadScalarOffAddrOp IntVec 16 W8) = 1132+primOpTag (VecReadScalarOffAddrOp IntVec 8 W16) = 1133+primOpTag (VecReadScalarOffAddrOp IntVec 4 W32) = 1134+primOpTag (VecReadScalarOffAddrOp IntVec 2 W64) = 1135+primOpTag (VecReadScalarOffAddrOp IntVec 32 W8) = 1136+primOpTag (VecReadScalarOffAddrOp IntVec 16 W16) = 1137+primOpTag (VecReadScalarOffAddrOp IntVec 8 W32) = 1138+primOpTag (VecReadScalarOffAddrOp IntVec 4 W64) = 1139+primOpTag (VecReadScalarOffAddrOp IntVec 64 W8) = 1140+primOpTag (VecReadScalarOffAddrOp IntVec 32 W16) = 1141+primOpTag (VecReadScalarOffAddrOp IntVec 16 W32) = 1142+primOpTag (VecReadScalarOffAddrOp IntVec 8 W64) = 1143+primOpTag (VecReadScalarOffAddrOp WordVec 16 W8) = 1144+primOpTag (VecReadScalarOffAddrOp WordVec 8 W16) = 1145+primOpTag (VecReadScalarOffAddrOp WordVec 4 W32) = 1146+primOpTag (VecReadScalarOffAddrOp WordVec 2 W64) = 1147+primOpTag (VecReadScalarOffAddrOp WordVec 32 W8) = 1148+primOpTag (VecReadScalarOffAddrOp WordVec 16 W16) = 1149+primOpTag (VecReadScalarOffAddrOp WordVec 8 W32) = 1150+primOpTag (VecReadScalarOffAddrOp WordVec 4 W64) = 1151+primOpTag (VecReadScalarOffAddrOp WordVec 64 W8) = 1152+primOpTag (VecReadScalarOffAddrOp WordVec 32 W16) = 1153+primOpTag (VecReadScalarOffAddrOp WordVec 16 W32) = 1154+primOpTag (VecReadScalarOffAddrOp WordVec 8 W64) = 1155+primOpTag (VecReadScalarOffAddrOp FloatVec 4 W32) = 1156+primOpTag (VecReadScalarOffAddrOp FloatVec 2 W64) = 1157+primOpTag (VecReadScalarOffAddrOp FloatVec 8 W32) = 1158+primOpTag (VecReadScalarOffAddrOp FloatVec 4 W64) = 1159+primOpTag (VecReadScalarOffAddrOp FloatVec 16 W32) = 1160+primOpTag (VecReadScalarOffAddrOp FloatVec 8 W64) = 1161+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W8) = 1162+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W16) = 1163+primOpTag (VecWriteScalarOffAddrOp IntVec 4 W32) = 1164+primOpTag (VecWriteScalarOffAddrOp IntVec 2 W64) = 1165+primOpTag (VecWriteScalarOffAddrOp IntVec 32 W8) = 1166+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W16) = 1167+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W32) = 1168+primOpTag (VecWriteScalarOffAddrOp IntVec 4 W64) = 1169+primOpTag (VecWriteScalarOffAddrOp IntVec 64 W8) = 1170+primOpTag (VecWriteScalarOffAddrOp IntVec 32 W16) = 1171+primOpTag (VecWriteScalarOffAddrOp IntVec 16 W32) = 1172+primOpTag (VecWriteScalarOffAddrOp IntVec 8 W64) = 1173+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W8) = 1174+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W16) = 1175+primOpTag (VecWriteScalarOffAddrOp WordVec 4 W32) = 1176+primOpTag (VecWriteScalarOffAddrOp WordVec 2 W64) = 1177+primOpTag (VecWriteScalarOffAddrOp WordVec 32 W8) = 1178+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W16) = 1179+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W32) = 1180+primOpTag (VecWriteScalarOffAddrOp WordVec 4 W64) = 1181+primOpTag (VecWriteScalarOffAddrOp WordVec 64 W8) = 1182+primOpTag (VecWriteScalarOffAddrOp WordVec 32 W16) = 1183+primOpTag (VecWriteScalarOffAddrOp WordVec 16 W32) = 1184+primOpTag (VecWriteScalarOffAddrOp WordVec 8 W64) = 1185+primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W32) = 1186+primOpTag (VecWriteScalarOffAddrOp FloatVec 2 W64) = 1187+primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W32) = 1188+primOpTag (VecWriteScalarOffAddrOp FloatVec 4 W64) = 1189+primOpTag (VecWriteScalarOffAddrOp FloatVec 16 W32) = 1190+primOpTag (VecWriteScalarOffAddrOp FloatVec 8 W64) = 1191+primOpTag PrefetchByteArrayOp3 = 1192+primOpTag PrefetchMutableByteArrayOp3 = 1193+primOpTag PrefetchAddrOp3 = 1194+primOpTag PrefetchValueOp3 = 1195+primOpTag PrefetchByteArrayOp2 = 1196+primOpTag PrefetchMutableByteArrayOp2 = 1197+primOpTag PrefetchAddrOp2 = 1198+primOpTag PrefetchValueOp2 = 1199+primOpTag PrefetchByteArrayOp1 = 1200+primOpTag PrefetchMutableByteArrayOp1 = 1201+primOpTag PrefetchAddrOp1 = 1202+primOpTag PrefetchValueOp1 = 1203+primOpTag PrefetchByteArrayOp0 = 1204+primOpTag PrefetchMutableByteArrayOp0 = 1205+primOpTag PrefetchAddrOp0 = 1206+primOpTag PrefetchValueOp0 = 1207

ghc-lib/stage0/lib/ghcversion.h view

@@ -6,7 +6,7 @@ #endif  #define __GLASGOW_HASKELL_PATCHLEVEL1__ 0-#define __GLASGOW_HASKELL_PATCHLEVEL2__ 20200131+#define __GLASGOW_HASKELL_PATCHLEVEL2__ 20200229  #define MIN_VERSION_GLASGOW_HASKELL(ma,mi,pl1,pl2) (\    ((ma)*100+(mi)) <  __GLASGOW_HASKELL__ || \

ghc-lib/stage0/lib/llvm-targets view

@@ -1,6 +1,7 @@ [("i386-unknown-windows", ("e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32", "pentium4", "")) ,("i686-unknown-windows", ("e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32", "pentium4", "")) ,("x86_64-unknown-windows", ("e-m:w-i64:64-f80:128-n8:16:32:64-S128", "x86-64", ""))+,("arm-unknown-linux-gnueabi", ("e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64", "arm7tdmi", "+soft-float -fp16 -vfp2 -vfp2sp -vfp2d16 -vfp2d16sp -vfp3 -vfp3sp -vfp3d16 -vfp3d16sp -vfp4 -vfp4sp -vfp4d16 -vfp4d16sp -fp-armv8 -fp-armv8sp -fp-armv8d16 -fp-armv8d16sp -fullfp16 -neon -crypto -dotprod -fp16fml -fp64 -d32 -fpregs +strict-align")) ,("arm-unknown-linux-gnueabihf", ("e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64", "arm1176jzf-s", "+strict-align")) ,("arm-unknown-linux-musleabihf", ("e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64", "arm1176jzf-s", "+strict-align")) ,("armv6-unknown-linux-gnueabihf", ("e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64", "arm1136jf-s", "+strict-align"))

ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs view

@@ -3,19 +3,19 @@ import Prelude -- See Note [Why do we import Prelude here?]  cProjectGitCommitId   :: String-cProjectGitCommitId   = "01b15b835a7555c501df862b4dc8cc8eaff86afc"+cProjectGitCommitId   = "04d30137771a6cf8a18fda1ced25f78d0b2eb204"  cProjectVersion       :: String-cProjectVersion       = "8.11.0.20200131"+cProjectVersion       = "8.11.0.20200229"  cProjectVersionInt    :: String cProjectVersionInt    = "811"  cProjectPatchLevel    :: String-cProjectPatchLevel    = "020200131"+cProjectPatchLevel    = "020200229"  cProjectPatchLevel1   :: String cProjectPatchLevel1   = "0"  cProjectPatchLevel2   :: String-cProjectPatchLevel2   = "20200131"+cProjectPatchLevel2   = "20200229"

includes/CodeGen.Platform.hs view

@@ -4,7 +4,7 @@     || defined(MACHREGS_sparc) || defined(MACHREGS_powerpc)) import PlainPanic #endif-import Reg+import GHC.Platform.Reg  #include "stg/MachRegs.h"

libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs view

@@ -8,7 +8,7 @@ -- -- A data type defining the language extensions supported by GHC. ---{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE DeriveGeneric, Safe #-} module GHC.LanguageExtensions.Type ( Extension(..) ) where  import Prelude -- See note [Why do we import Prelude here?]

libraries/ghc-heap/GHC/Exts/Heap.hs view

@@ -122,7 +122,7 @@                 ptrList = amap' Box $ Array 0 (pelems - 1) pelems pointers             pure (Ptr iptr, rawWds, ptrList) --- From compiler/ghci/RtClosureInspect.hs+-- From GHC.Runtime.Heap.Inspect amap' :: (t -> b) -> Array Int t -> [b] amap' f (Array i0 i _ arr#) = map g [0 .. i - i0]     where g (I# i#) = case indexArray# arr# i# of@@ -145,7 +145,7 @@     case tipe itbl of         t | t >= CONSTR && t <= CONSTR_NOCAF -> do             (p, m, n) <- dataConNames iptr-            if m == "ByteCodeInstr" && n == "BreakInfo"+            if m == "GHC.ByteCode.Instr" && n == "BreakInfo"               then pure $ UnsupportedClosure itbl               else pure $ ConstrClosure itbl pts npts p m n

libraries/ghci/GHCi/BreakArray.hs view

@@ -19,7 +19,7 @@ module GHCi.BreakArray     (       BreakArray-          (BA) -- constructor is exported only for ByteCodeGen+          (BA) -- constructor is exported only for GHC.CoreToByteCode     , newBreakArray     , getBreak     , setBreakOn

libraries/template-haskell/Language/Haskell/TH.hs view

@@ -4,6 +4,7 @@ <http://www.haskell.org/haskellwiki/Template_Haskell>  -}+{-# LANGUAGE Safe #-} module Language.Haskell.TH(         -- * The monad and its operations         Q,

libraries/template-haskell/Language/Haskell/TH/LanguageExtensions.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE Safe #-} ----------------------------------------------------------------------------- -- | -- Module      :  Language.Haskell.TH.LanguageExtensions

libraries/template-haskell/Language/Haskell/TH/Lib.hs view

@@ -1,3 +1,5 @@+{-# LANGUAGE Safe #-}+ -- | -- Language.Haskell.TH.Lib contains lots of useful helper functions for -- generating and manipulating Template Haskell terms

libraries/template-haskell/Language/Haskell/TH/Lib/Internal.hs view

@@ -1,3 +1,5 @@+{-# LANGUAGE Safe #-}+ -- | -- Language.Haskell.TH.Lib.Internal exposes some additional functionality that -- is used internally in GHC's integration with Template Haskell. This is not a

libraries/template-haskell/Language/Haskell/TH/Lib/Map.hs view

@@ -1,4 +1,5 @@ {-# LANGUAGE BangPatterns #-}+{-# LANGUAGE Safe #-}  -- This is a non-exposed internal module --

libraries/template-haskell/Language/Haskell/TH/Ppr.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE Safe #-} -- | contains a prettyprinter for the -- Template Haskell datatypes

libraries/template-haskell/Language/Haskell/TH/PprLib.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FlexibleInstances, Safe #-}  -- | Monadic front-end to Text.PrettyPrint

libraries/template-haskell/Language/Haskell/TH/Syntax.hs view

@@ -677,8 +677,9 @@   ------------------------------------------------------- The following operations are used solely in DsMeta when desugaring brackets--- They are not necessary for the user, who can use ordinary return and (>>=) etc+-- The following operations are used solely in GHC.HsToCore.Quote when+-- desugaring brackets. They are not necessary for the user, who can use+-- ordinary return and (>>=) etc  sequenceQ :: forall m . Monad m => forall a . [m a] -> m [a] sequenceQ = sequence@@ -1073,13 +1074,13 @@ -- expressions and patterns; @antiQ@ allows you to override type-specific -- cases, a common usage is just @const Nothing@, which results in -- no overloading.-dataToQa  ::  forall a k q. Data a+dataToQa  ::  forall m a k q. (Quote m, Data a)           =>  (Name -> k)-          ->  (Lit -> Q q)-          ->  (k -> [Q q] -> Q q)-          ->  (forall b . Data b => b -> Maybe (Q q))+          ->  (Lit -> m q)+          ->  (k -> [m q] -> m q)+          ->  (forall b . Data b => b -> Maybe (m q))           ->  a-          ->  Q q+          ->  m q dataToQa mkCon mkLit appCon antiQ t =     case antiQ t of       Nothing ->@@ -1116,7 +1117,7 @@                     tyconPkg = tyConPackage tycon                     tyconMod = tyConModule  tycon -                conArgs :: [Q q]+                conArgs :: [m q]                 conArgs = gmapQ (dataToQa mkCon mkLit appCon antiQ) t             IntConstr n ->                 mkLit $ IntegerL n@@ -1158,14 +1159,14 @@   "pack" is defined in a different module than the data type "Text".   -} --- | 'dataToExpQ' converts a value to a 'Q Exp' representation of the+-- | 'dataToExpQ' converts a value to a 'Exp' representation of the -- same value, in the SYB style. It is generalized to take a function -- override type-specific cases; see 'liftData' for a more commonly -- used variant.-dataToExpQ  ::  Data a-            =>  (forall b . Data b => b -> Maybe (Q Exp))+dataToExpQ  ::  (Quote m, Data a)+            =>  (forall b . Data b => b -> Maybe (m Exp))             ->  a-            ->  Q Exp+            ->  m Exp dataToExpQ = dataToQa varOrConE litE (foldl appE)     where           -- Make sure that VarE is used if the Constr value relies on a@@ -1175,23 +1176,23 @@             case nameSpace s of                  Just VarName  -> return (VarE s)                  Just DataName -> return (ConE s)-                 _ -> fail $ "Can't construct an expression from name "-                          ++ showName s+                 _ -> error $ "Can't construct an expression from name "+                           ++ showName s           appE x y = do { a <- x; b <- y; return (AppE a b)}           litE c = return (LitE c)  -- | 'liftData' is a variant of 'lift' in the 'Lift' type class which -- works for any type with a 'Data' instance.-liftData :: Data a => a -> Q Exp+liftData :: (Quote m, Data a) => a -> m Exp liftData = dataToExpQ (const Nothing) --- | 'dataToPatQ' converts a value to a 'Q Pat' representation of the same+-- | 'dataToPatQ' converts a value to a 'Pat' representation of the same -- value, in the SYB style. It takes a function to handle type-specific cases, -- alternatively, pass @const Nothing@ to get default behavior.-dataToPatQ  ::  Data a-            =>  (forall b . Data b => b -> Maybe (Q Pat))+dataToPatQ  ::  (Quote m, Data a)+            =>  (forall b . Data b => b -> Maybe (m Pat))             ->  a-            ->  Q Pat+            ->  m Pat dataToPatQ = dataToQa id litP conP     where litP l = return (LitP l)           conP n ps =@@ -1199,8 +1200,8 @@                 Just DataName -> do                     ps' <- sequence ps                     return (ConP n ps')-                _ -> fail $ "Can't construct a pattern from name "-                         ++ showName n+                _ -> error $ "Can't construct a pattern from name "+                          ++ showName n  ----------------------------------------------------- --              Names and uniques